[MINOR] Cleanup spark/mr instruction parsing and type handling Project: http://git-wip-us.apache.org/repos/asf/systemml/repo Commit: http://git-wip-us.apache.org/repos/asf/systemml/commit/4d1ee8e1 Tree: http://git-wip-us.apache.org/repos/asf/systemml/tree/4d1ee8e1 Diff: http://git-wip-us.apache.org/repos/asf/systemml/diff/4d1ee8e1
Branch: refs/heads/master Commit: 4d1ee8e193d48d25d8c16652cf27f3cede7252ae Parents: ea77cb4 Author: Matthias Boehm <[email protected]> Authored: Thu Jan 4 13:16:04 2018 -0800 Committer: Matthias Boehm <[email protected]> Committed: Thu Jan 4 13:16:04 2018 -0800 ---------------------------------------------------------------------- .../hops/cost/CostEstimatorStaticRuntime.java | 18 +- .../instructions/CPInstructionParser.java | 6 +- .../runtime/instructions/InstructionParser.java | 8 +- .../runtime/instructions/InstructionUtils.java | 8 +- .../instructions/MRInstructionParser.java | 346 +++++++++--------- .../instructions/SPInstructionParser.java | 347 +++++++++---------- .../runtime/instructions/cp/CPInstruction.java | 2 +- .../mr/AggregateBinaryInstruction.java | 4 +- .../instructions/mr/AggregateInstruction.java | 3 +- .../mr/AggregateUnaryInstruction.java | 4 +- .../instructions/mr/AppendInstruction.java | 3 +- .../mr/BinUaggChainInstruction.java | 9 +- .../instructions/mr/BinaryInstruction.java | 7 +- .../instructions/mr/BinaryMInstruction.java | 7 +- .../mr/BinaryMRInstructionBase.java | 4 +- .../instructions/mr/CM_N_COVInstruction.java | 3 +- .../instructions/mr/CSVWriteInstruction.java | 3 +- .../mr/CombineBinaryInstruction.java | 3 +- .../mr/CombineTernaryInstruction.java | 3 +- .../mr/CombineUnaryInstruction.java | 6 +- .../mr/CumulativeOffsetInstruction.java | 2 +- .../mr/CumulativeSplitInstruction.java | 2 +- .../instructions/mr/DataGenMRInstruction.java | 5 +- .../mr/DataPartitionMRInstruction.java | 2 +- .../mr/GroupedAggregateInstruction.java | 4 +- .../mr/GroupedAggregateMInstruction.java | 2 +- .../instructions/mr/MMTSJMRInstruction.java | 4 +- .../runtime/instructions/mr/MRInstruction.java | 21 +- .../mr/MapMultChainInstruction.java | 12 +- .../mr/MatrixReshapeMRInstruction.java | 4 +- .../instructions/mr/PMMJMRInstruction.java | 5 +- .../mr/ParameterizedBuiltinMRInstruction.java | 4 +- .../instructions/mr/PickByCountInstruction.java | 17 +- .../instructions/mr/PlusMultInstruction.java | 2 +- .../instructions/mr/QuaternaryInstruction.java | 3 +- .../instructions/mr/RandInstruction.java | 3 +- .../mr/RangeBasedReIndexInstruction.java | 3 +- .../instructions/mr/ReblockInstruction.java | 2 +- .../mr/RemoveEmptyMRInstruction.java | 3 +- .../instructions/mr/ReorgInstruction.java | 9 +- .../instructions/mr/ReplicateInstruction.java | 3 +- .../instructions/mr/ScalarInstruction.java | 3 +- .../runtime/instructions/mr/SeqInstruction.java | 3 +- .../instructions/mr/TernaryInstruction.java | 110 +----- .../mr/UaggOuterChainInstruction.java | 10 +- .../instructions/mr/UnaryInstruction.java | 12 +- .../instructions/mr/UnaryMRInstructionBase.java | 4 +- .../instructions/mr/ZeroOutInstruction.java | 3 +- .../spark/AggregateTernarySPInstruction.java | 6 +- .../spark/AggregateUnarySPInstruction.java | 6 +- .../spark/AppendGAlignedSPInstruction.java | 3 +- .../spark/AppendGSPInstruction.java | 3 +- .../spark/AppendMSPInstruction.java | 3 +- .../spark/AppendRSPInstruction.java | 6 +- .../spark/ArithmeticBinarySPInstruction.java | 6 +- .../spark/BinUaggChainSPInstruction.java | 3 +- .../instructions/spark/BinarySPInstruction.java | 5 +- .../spark/BuiltinBinarySPInstruction.java | 6 +- .../spark/BuiltinNarySPInstruction.java | 3 +- .../spark/BuiltinUnarySPInstruction.java | 3 +- .../spark/CSVReblockSPInstruction.java | 2 +- .../instructions/spark/CastSPInstruction.java | 3 +- .../spark/CentralMomentSPInstruction.java | 5 +- .../spark/CheckpointSPInstruction.java | 6 +- .../spark/CompressionSPInstruction.java | 3 +- .../spark/ComputationSPInstruction.java | 10 +- .../spark/ConvolutionSPInstruction.java | 12 +- .../spark/CovarianceSPInstruction.java | 10 +- .../instructions/spark/CpmmSPInstruction.java | 6 +- .../spark/CumulativeAggregateSPInstruction.java | 8 +- .../spark/CumulativeOffsetSPInstruction.java | 6 +- .../spark/IndexingSPInstruction.java | 9 +- .../spark/MapmmChainSPInstruction.java | 16 +- .../instructions/spark/MapmmSPInstruction.java | 4 +- .../spark/MatrixReshapeSPInstruction.java | 4 +- ...ReturnParameterizedBuiltinSPInstruction.java | 3 +- .../instructions/spark/PMapmmSPInstruction.java | 3 +- .../ParameterizedBuiltinSPInstruction.java | 3 +- .../instructions/spark/PmmSPInstruction.java | 3 +- .../spark/QuantilePickSPInstruction.java | 3 +- .../spark/QuantileSortSPInstruction.java | 3 +- .../spark/QuaternarySPInstruction.java | 4 +- .../instructions/spark/RandSPInstruction.java | 2 +- .../spark/ReblockSPInstruction.java | 2 +- .../spark/RelationalBinarySPInstruction.java | 6 +- .../instructions/spark/ReorgSPInstruction.java | 4 +- .../instructions/spark/RmmSPInstruction.java | 3 +- .../instructions/spark/SPInstruction.java | 38 +- .../instructions/spark/SpoofSPInstruction.java | 3 +- .../spark/TernarySPInstruction.java | 2 +- .../instructions/spark/Tsmm2SPInstruction.java | 3 +- .../instructions/spark/TsmmSPInstruction.java | 3 +- .../spark/UaggOuterChainSPInstruction.java | 6 +- .../instructions/spark/UnarySPInstruction.java | 14 +- .../instructions/spark/WriteSPInstruction.java | 3 +- .../instructions/spark/ZipmmSPInstruction.java | 4 +- .../apache/sysml/runtime/matrix/DataGenMR.java | 8 +- .../org/apache/sysml/runtime/matrix/SortMR.java | 3 +- 98 files changed, 547 insertions(+), 787 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/systemml/blob/4d1ee8e1/src/main/java/org/apache/sysml/hops/cost/CostEstimatorStaticRuntime.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/hops/cost/CostEstimatorStaticRuntime.java b/src/main/java/org/apache/sysml/hops/cost/CostEstimatorStaticRuntime.java index 33df1d1..40bfe04 100644 --- a/src/main/java/org/apache/sysml/hops/cost/CostEstimatorStaticRuntime.java +++ b/src/main/java/org/apache/sysml/hops/cost/CostEstimatorStaticRuntime.java @@ -56,7 +56,7 @@ import org.apache.sysml.runtime.instructions.mr.PickByCountInstruction; import org.apache.sysml.runtime.instructions.mr.RemoveEmptyMRInstruction; import org.apache.sysml.runtime.instructions.mr.TernaryInstruction; import org.apache.sysml.runtime.instructions.mr.UnaryMRInstructionBase; -import org.apache.sysml.runtime.instructions.mr.MRInstruction.MRINSTRUCTION_TYPE; +import org.apache.sysml.runtime.instructions.mr.MRInstruction.MRType; import org.apache.sysml.runtime.matrix.data.MatrixBlock; import org.apache.sysml.runtime.matrix.mapred.DistributedCacheInput; import org.apache.sysml.runtime.matrix.operators.CMOperator; @@ -263,7 +263,7 @@ public class CostEstimatorStaticRuntime extends CostEstimator if( instCat != null && instCat.length()>0 ) { String[] linst = instCat.split( Lop.INSTRUCTION_DELIMITOR ); for( String tmp : linst ) { - if(InstructionUtils.getMRType(tmp)==MRINSTRUCTION_TYPE.Aggregate) + if(InstructionUtils.getMRType(tmp)==MRType.Aggregate) shuffleCosts += numMap * getFSWriteTime(vs[mapOutIx[i]]._rlen, vs[mapOutIx[i]]._clen, vs[mapOutIx[i]].getSparsity()) / numEPMap + numPMap * getFSWriteTime(vs[mapOutIx[i]]._rlen, vs[mapOutIx[i]]._clen, vs[mapOutIx[i]].getSparsity()) / numEPMap + numPMap * getFSReadTime(vs[mapOutIx[i]]._rlen, vs[mapOutIx[i]]._clen, vs[mapOutIx[i]].getSparsity()) / numEPRed; @@ -277,7 +277,7 @@ public class CostEstimatorStaticRuntime extends CostEstimator String[] linst = instCat.split( Lop.INSTRUCTION_DELIMITOR ); for( String tmp : linst ){ Object[] o = extractMRInstStatistics(tmp, vs); - if(InstructionUtils.getMRType(tmp)==MRINSTRUCTION_TYPE.Aggregate) + if(InstructionUtils.getMRType(tmp)==MRType.Aggregate) o[1] = new String[]{String.valueOf(numMap)}; String opcode = InstructionUtils.getOpCode(tmp); reduceCosts += getInstTimeEstimate(opcode, (VarStats[])o[0], (String[])o[1], ExecType.MR); @@ -1063,7 +1063,7 @@ public class CostEstimatorStaticRuntime extends CostEstimator //reduction by factor 2 because matrix mult better than //average flop count if( MMTSJType.valueOf(args[0]).isLeft() ) { //lefttranspose - if( !rightSparse ) //dense + if( !rightSparse ) //dense return d1m * d1n * d1s * d1n /2; else //sparse return d1m * d1n * d1s * d1n * d1s /2; @@ -1074,25 +1074,21 @@ public class CostEstimatorStaticRuntime extends CostEstimator else //sparse return d1m * d1n * d1s //reorg sparse + d1m * d1n * d1s * d1n * d1s /2; //core tsmm - } + } return 0; case Partition: return d1m * d1n * d1s + //partitioning costs - (inMR ? 0 : //include write cost if in CP + (inMR ? 0 : //include write cost if in CP getHDFSWriteTime(d1m, d1n, d1s)* DEFAULT_FLOPS); - - case INVALID: - return 0; default: throw new DMLRuntimeException("CostEstimator: unsupported instruction type: "+optype); } - } //if not found in CP instructions - MRINSTRUCTION_TYPE mrtype = MRInstructionParser.String2MRInstructionType.get(optype); + MRType mrtype = MRInstructionParser.String2MRInstructionType.get(optype); if ( mrtype != null ) //for specific MR ops { switch(mrtype) http://git-wip-us.apache.org/repos/asf/systemml/blob/4d1ee8e1/src/main/java/org/apache/sysml/runtime/instructions/CPInstructionParser.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/instructions/CPInstructionParser.java b/src/main/java/org/apache/sysml/runtime/instructions/CPInstructionParser.java index 7ad91db..c1fc7c5 100644 --- a/src/main/java/org/apache/sysml/runtime/instructions/CPInstructionParser.java +++ b/src/main/java/org/apache/sysml/runtime/instructions/CPInstructionParser.java @@ -428,7 +428,7 @@ public class CPInstructionParser extends InstructionParser return MMChainCPInstruction.parseInstruction(str); case Partition: - return DataPartitionCPInstruction.parseInstruction(str); + return DataPartitionCPInstruction.parseInstruction(str); case CentralMoment: return CentralMomentCPInstruction.parseInstruction(str); @@ -437,13 +437,11 @@ public class CPInstructionParser extends InstructionParser return CovarianceCPInstruction.parseInstruction(str); case Compression: - return (CPInstruction) CompressionCPInstruction.parseInstruction(str); + return (CPInstruction) CompressionCPInstruction.parseInstruction(str); case SpoofFused: return SpoofCPInstruction.parseInstruction(str); - case INVALID: - default: throw new DMLRuntimeException("Invalid CP Instruction Type: " + cptype ); } http://git-wip-us.apache.org/repos/asf/systemml/blob/4d1ee8e1/src/main/java/org/apache/sysml/runtime/instructions/InstructionParser.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/instructions/InstructionParser.java b/src/main/java/org/apache/sysml/runtime/instructions/InstructionParser.java index b38ccff..7a8ef75 100644 --- a/src/main/java/org/apache/sysml/runtime/instructions/InstructionParser.java +++ b/src/main/java/org/apache/sysml/runtime/instructions/InstructionParser.java @@ -23,8 +23,8 @@ import org.apache.sysml.lops.LopProperties.ExecType; import org.apache.sysml.runtime.DMLRuntimeException; import org.apache.sysml.runtime.instructions.cp.CPInstruction.CPType; import org.apache.sysml.runtime.instructions.gpu.GPUInstruction.GPUINSTRUCTION_TYPE; -import org.apache.sysml.runtime.instructions.mr.MRInstruction.MRINSTRUCTION_TYPE; -import org.apache.sysml.runtime.instructions.spark.SPInstruction.SPINSTRUCTION_TYPE; +import org.apache.sysml.runtime.instructions.mr.MRInstruction.MRType; +import org.apache.sysml.runtime.instructions.spark.SPInstruction.SPType; public class InstructionParser @@ -46,7 +46,7 @@ public class InstructionParser } else if ( execType.equalsIgnoreCase(ExecType.SPARK.toString()) ) { - SPINSTRUCTION_TYPE sptype = InstructionUtils.getSPType(str); + SPType sptype = InstructionUtils.getSPType(str); if( sptype == null ) throw new DMLRuntimeException("Unknown SPARK instruction: " + str); return SPInstructionParser.parseSingleInstruction (sptype, str); @@ -59,7 +59,7 @@ public class InstructionParser return GPUInstructionParser.parseSingleInstruction (gputype, str); } else if ( execType.equalsIgnoreCase("MR") ) { - MRINSTRUCTION_TYPE mrtype = InstructionUtils.getMRType(str); + MRType mrtype = InstructionUtils.getMRType(str); if( mrtype == null ) throw new DMLRuntimeException("Unknown MR instruction: " + str); return MRInstructionParser.parseSingleInstruction (mrtype, str); http://git-wip-us.apache.org/repos/asf/systemml/blob/4d1ee8e1/src/main/java/org/apache/sysml/runtime/instructions/InstructionUtils.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/instructions/InstructionUtils.java b/src/main/java/org/apache/sysml/runtime/instructions/InstructionUtils.java index 8752021..633d80f 100644 --- a/src/main/java/org/apache/sysml/runtime/instructions/InstructionUtils.java +++ b/src/main/java/org/apache/sysml/runtime/instructions/InstructionUtils.java @@ -75,8 +75,8 @@ import org.apache.sysml.runtime.functionobjects.ReduceRow; import org.apache.sysml.runtime.functionobjects.Xor; import org.apache.sysml.runtime.instructions.cp.CPInstruction.CPType; import org.apache.sysml.runtime.instructions.gpu.GPUInstruction.GPUINSTRUCTION_TYPE; -import org.apache.sysml.runtime.instructions.mr.MRInstruction.MRINSTRUCTION_TYPE; -import org.apache.sysml.runtime.instructions.spark.SPInstruction.SPINSTRUCTION_TYPE; +import org.apache.sysml.runtime.instructions.mr.MRInstruction.MRType; +import org.apache.sysml.runtime.instructions.spark.SPInstruction.SPType; import org.apache.sysml.runtime.matrix.operators.AggregateOperator; import org.apache.sysml.runtime.matrix.operators.AggregateTernaryOperator; import org.apache.sysml.runtime.matrix.operators.AggregateUnaryOperator; @@ -195,11 +195,11 @@ public class InstructionUtils return str.substring(ix1+1, ix2); } - public static MRINSTRUCTION_TYPE getMRType( String str ) { + public static MRType getMRType( String str ) { return MRInstructionParser.String2MRInstructionType.get( getOpCode(str) ); } - public static SPINSTRUCTION_TYPE getSPType( String str ) { + public static SPType getSPType( String str ) { return SPInstructionParser.String2SPInstructionType.get( getOpCode(str) ); } http://git-wip-us.apache.org/repos/asf/systemml/blob/4d1ee8e1/src/main/java/org/apache/sysml/runtime/instructions/MRInstructionParser.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/instructions/MRInstructionParser.java b/src/main/java/org/apache/sysml/runtime/instructions/MRInstructionParser.java index b68bfe2..ee1e923 100644 --- a/src/main/java/org/apache/sysml/runtime/instructions/MRInstructionParser.java +++ b/src/main/java/org/apache/sysml/runtime/instructions/MRInstructionParser.java @@ -78,230 +78,230 @@ import org.apache.sysml.runtime.instructions.mr.TernaryInstruction; import org.apache.sysml.runtime.instructions.mr.UaggOuterChainInstruction; import org.apache.sysml.runtime.instructions.mr.UnaryInstruction; import org.apache.sysml.runtime.instructions.mr.ZeroOutInstruction; -import org.apache.sysml.runtime.instructions.mr.MRInstruction.MRINSTRUCTION_TYPE; +import org.apache.sysml.runtime.instructions.mr.MRInstruction.MRType; import org.apache.sysml.runtime.matrix.SortMR; public class MRInstructionParser extends InstructionParser { - static public HashMap<String, MRINSTRUCTION_TYPE> String2MRInstructionType; + static public HashMap<String, MRType> String2MRInstructionType; static { String2MRInstructionType = new HashMap<>(); // AGG Instruction Opcodes - String2MRInstructionType.put( "a+" , MRINSTRUCTION_TYPE.Aggregate); - String2MRInstructionType.put( "ak+" , MRINSTRUCTION_TYPE.Aggregate); - String2MRInstructionType.put( "asqk+" , MRINSTRUCTION_TYPE.Aggregate); - String2MRInstructionType.put( "a*" , MRINSTRUCTION_TYPE.Aggregate); - String2MRInstructionType.put( "amax" , MRINSTRUCTION_TYPE.Aggregate); - String2MRInstructionType.put( "amin" , MRINSTRUCTION_TYPE.Aggregate); - String2MRInstructionType.put( "amean" , MRINSTRUCTION_TYPE.Aggregate); - String2MRInstructionType.put( "avar" , MRINSTRUCTION_TYPE.Aggregate); - String2MRInstructionType.put( "arimax" , MRINSTRUCTION_TYPE.Aggregate); - String2MRInstructionType.put( "arimin" , MRINSTRUCTION_TYPE.Aggregate); + String2MRInstructionType.put( "a+" , MRType.Aggregate); + String2MRInstructionType.put( "ak+" , MRType.Aggregate); + String2MRInstructionType.put( "asqk+" , MRType.Aggregate); + String2MRInstructionType.put( "a*" , MRType.Aggregate); + String2MRInstructionType.put( "amax" , MRType.Aggregate); + String2MRInstructionType.put( "amin" , MRType.Aggregate); + String2MRInstructionType.put( "amean" , MRType.Aggregate); + String2MRInstructionType.put( "avar" , MRType.Aggregate); + String2MRInstructionType.put( "arimax" , MRType.Aggregate); + String2MRInstructionType.put( "arimin" , MRType.Aggregate); // AGG_BINARY Instruction Opcodes - String2MRInstructionType.put( "cpmm" , MRINSTRUCTION_TYPE.AggregateBinary); - String2MRInstructionType.put( "rmm" , MRINSTRUCTION_TYPE.AggregateBinary); - String2MRInstructionType.put( MapMult.OPCODE, MRINSTRUCTION_TYPE.AggregateBinary); + String2MRInstructionType.put( "cpmm" , MRType.AggregateBinary); + String2MRInstructionType.put( "rmm" , MRType.AggregateBinary); + String2MRInstructionType.put( MapMult.OPCODE, MRType.AggregateBinary); // AGG_UNARY Instruction Opcodes - String2MRInstructionType.put( "ua+" , MRINSTRUCTION_TYPE.AggregateUnary); - String2MRInstructionType.put( "uar+" , MRINSTRUCTION_TYPE.AggregateUnary); - String2MRInstructionType.put( "uac+" , MRINSTRUCTION_TYPE.AggregateUnary); - String2MRInstructionType.put( "uak+" , MRINSTRUCTION_TYPE.AggregateUnary); - String2MRInstructionType.put( "uark+" , MRINSTRUCTION_TYPE.AggregateUnary); - String2MRInstructionType.put( "uack+" , MRINSTRUCTION_TYPE.AggregateUnary); - String2MRInstructionType.put( "uasqk+" , MRINSTRUCTION_TYPE.AggregateUnary); - String2MRInstructionType.put( "uarsqk+", MRINSTRUCTION_TYPE.AggregateUnary); - String2MRInstructionType.put( "uacsqk+", MRINSTRUCTION_TYPE.AggregateUnary); - String2MRInstructionType.put( "uamean", MRINSTRUCTION_TYPE.AggregateUnary); - String2MRInstructionType.put( "uarmean",MRINSTRUCTION_TYPE.AggregateUnary); - String2MRInstructionType.put( "uacmean",MRINSTRUCTION_TYPE.AggregateUnary); - String2MRInstructionType.put( "uavar", MRINSTRUCTION_TYPE.AggregateUnary); - String2MRInstructionType.put( "uarvar", MRINSTRUCTION_TYPE.AggregateUnary); - String2MRInstructionType.put( "uacvar", MRINSTRUCTION_TYPE.AggregateUnary); - String2MRInstructionType.put( "ua*" , MRINSTRUCTION_TYPE.AggregateUnary); - String2MRInstructionType.put( "uamax" , MRINSTRUCTION_TYPE.AggregateUnary); - String2MRInstructionType.put( "uamin" , MRINSTRUCTION_TYPE.AggregateUnary); - String2MRInstructionType.put( "uatrace" , MRINSTRUCTION_TYPE.AggregateUnary); - String2MRInstructionType.put( "uaktrace", MRINSTRUCTION_TYPE.AggregateUnary); - String2MRInstructionType.put( "uarmax" , MRINSTRUCTION_TYPE.AggregateUnary); - String2MRInstructionType.put( "uarimax" , MRINSTRUCTION_TYPE.AggregateUnary); - String2MRInstructionType.put( "uacmax" , MRINSTRUCTION_TYPE.AggregateUnary); - String2MRInstructionType.put( "uarmin" , MRINSTRUCTION_TYPE.AggregateUnary); - String2MRInstructionType.put( "uarimin" , MRINSTRUCTION_TYPE.AggregateUnary); - String2MRInstructionType.put( "uacmin" , MRINSTRUCTION_TYPE.AggregateUnary); + String2MRInstructionType.put( "ua+" , MRType.AggregateUnary); + String2MRInstructionType.put( "uar+" , MRType.AggregateUnary); + String2MRInstructionType.put( "uac+" , MRType.AggregateUnary); + String2MRInstructionType.put( "uak+" , MRType.AggregateUnary); + String2MRInstructionType.put( "uark+" , MRType.AggregateUnary); + String2MRInstructionType.put( "uack+" , MRType.AggregateUnary); + String2MRInstructionType.put( "uasqk+" , MRType.AggregateUnary); + String2MRInstructionType.put( "uarsqk+", MRType.AggregateUnary); + String2MRInstructionType.put( "uacsqk+", MRType.AggregateUnary); + String2MRInstructionType.put( "uamean", MRType.AggregateUnary); + String2MRInstructionType.put( "uarmean",MRType.AggregateUnary); + String2MRInstructionType.put( "uacmean",MRType.AggregateUnary); + String2MRInstructionType.put( "uavar", MRType.AggregateUnary); + String2MRInstructionType.put( "uarvar", MRType.AggregateUnary); + String2MRInstructionType.put( "uacvar", MRType.AggregateUnary); + String2MRInstructionType.put( "ua*" , MRType.AggregateUnary); + String2MRInstructionType.put( "uamax" , MRType.AggregateUnary); + String2MRInstructionType.put( "uamin" , MRType.AggregateUnary); + String2MRInstructionType.put( "uatrace" , MRType.AggregateUnary); + String2MRInstructionType.put( "uaktrace", MRType.AggregateUnary); + String2MRInstructionType.put( "uarmax" , MRType.AggregateUnary); + String2MRInstructionType.put( "uarimax" , MRType.AggregateUnary); + String2MRInstructionType.put( "uacmax" , MRType.AggregateUnary); + String2MRInstructionType.put( "uarmin" , MRType.AggregateUnary); + String2MRInstructionType.put( "uarimin" , MRType.AggregateUnary); + String2MRInstructionType.put( "uacmin" , MRType.AggregateUnary); // BUILTIN Instruction Opcodes - String2MRInstructionType.put( "abs" , MRINSTRUCTION_TYPE.Unary); - String2MRInstructionType.put( "sin" , MRINSTRUCTION_TYPE.Unary); - String2MRInstructionType.put( "cos" , MRINSTRUCTION_TYPE.Unary); - String2MRInstructionType.put( "tan" , MRINSTRUCTION_TYPE.Unary); - String2MRInstructionType.put( "asin" , MRINSTRUCTION_TYPE.Unary); - String2MRInstructionType.put( "acos" , MRINSTRUCTION_TYPE.Unary); - String2MRInstructionType.put( "atan" , MRINSTRUCTION_TYPE.Unary); - String2MRInstructionType.put( "sign" , MRINSTRUCTION_TYPE.Unary); - String2MRInstructionType.put( "sqrt" , MRINSTRUCTION_TYPE.Unary); - String2MRInstructionType.put( "exp" , MRINSTRUCTION_TYPE.Unary); - String2MRInstructionType.put( "log" , MRINSTRUCTION_TYPE.Unary); - String2MRInstructionType.put( "log_nz" , MRINSTRUCTION_TYPE.Unary); - String2MRInstructionType.put( "slog" , MRINSTRUCTION_TYPE.Unary); - String2MRInstructionType.put( "pow" , MRINSTRUCTION_TYPE.Unary); - String2MRInstructionType.put( "round", MRINSTRUCTION_TYPE.Unary); - String2MRInstructionType.put( "ceil" , MRINSTRUCTION_TYPE.Unary); - String2MRInstructionType.put( "floor", MRINSTRUCTION_TYPE.Unary); - String2MRInstructionType.put( "sprop", MRINSTRUCTION_TYPE.Unary); - String2MRInstructionType.put( "sigmoid", MRINSTRUCTION_TYPE.Unary); - String2MRInstructionType.put( "sel+", MRINSTRUCTION_TYPE.Unary); + String2MRInstructionType.put( "abs" , MRType.Unary); + String2MRInstructionType.put( "sin" , MRType.Unary); + String2MRInstructionType.put( "cos" , MRType.Unary); + String2MRInstructionType.put( "tan" , MRType.Unary); + String2MRInstructionType.put( "asin" , MRType.Unary); + String2MRInstructionType.put( "acos" , MRType.Unary); + String2MRInstructionType.put( "atan" , MRType.Unary); + String2MRInstructionType.put( "sign" , MRType.Unary); + String2MRInstructionType.put( "sqrt" , MRType.Unary); + String2MRInstructionType.put( "exp" , MRType.Unary); + String2MRInstructionType.put( "log" , MRType.Unary); + String2MRInstructionType.put( "log_nz" , MRType.Unary); + String2MRInstructionType.put( "slog" , MRType.Unary); + String2MRInstructionType.put( "pow" , MRType.Unary); + String2MRInstructionType.put( "round", MRType.Unary); + String2MRInstructionType.put( "ceil" , MRType.Unary); + String2MRInstructionType.put( "floor", MRType.Unary); + String2MRInstructionType.put( "sprop", MRType.Unary); + String2MRInstructionType.put( "sigmoid", MRType.Unary); + String2MRInstructionType.put( "sel+", MRType.Unary); // Specific UNARY Instruction Opcodes - String2MRInstructionType.put( "tsmm" , MRINSTRUCTION_TYPE.MMTSJ); - String2MRInstructionType.put( "pmm" , MRINSTRUCTION_TYPE.PMMJ); - String2MRInstructionType.put( MapMultChain.OPCODE, MRINSTRUCTION_TYPE.MapMultChain); - String2MRInstructionType.put( "binuaggchain", MRINSTRUCTION_TYPE.BinUaggChain); + String2MRInstructionType.put( "tsmm" , MRType.MMTSJ); + String2MRInstructionType.put( "pmm" , MRType.PMMJ); + String2MRInstructionType.put( MapMultChain.OPCODE, MRType.MapMultChain); + String2MRInstructionType.put( "binuaggchain", MRType.BinUaggChain); // BINARY and SCALAR Instruction Opcodes - String2MRInstructionType.put( "+" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "-" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "s-r" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "*" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "/" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "%%" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "%/%" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "1-*" , MRINSTRUCTION_TYPE.ArithmeticBinary); //special * case - String2MRInstructionType.put( "so" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "^" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "max" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "min" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( ">" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( ">=" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "<" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "<=" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "==" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "!=" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "^" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "^2" , MRINSTRUCTION_TYPE.ArithmeticBinary); //special ^ case - String2MRInstructionType.put( "*2" , MRINSTRUCTION_TYPE.ArithmeticBinary); //special * case - String2MRInstructionType.put( "-nz" , MRINSTRUCTION_TYPE.ArithmeticBinary); //special - case - String2MRInstructionType.put( "&&" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "||" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "xor" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "+*" , MRINSTRUCTION_TYPE.ArithmeticBinary2); - String2MRInstructionType.put( "-*" , MRINSTRUCTION_TYPE.ArithmeticBinary2); + String2MRInstructionType.put( "+" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "-" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "s-r" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "*" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "/" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "%%" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "%/%" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "1-*" , MRType.ArithmeticBinary); //special * case + String2MRInstructionType.put( "so" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "^" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "max" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "min" , MRType.ArithmeticBinary); + String2MRInstructionType.put( ">" , MRType.ArithmeticBinary); + String2MRInstructionType.put( ">=" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "<" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "<=" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "==" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "!=" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "^" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "^2" , MRType.ArithmeticBinary); //special ^ case + String2MRInstructionType.put( "*2" , MRType.ArithmeticBinary); //special * case + String2MRInstructionType.put( "-nz" , MRType.ArithmeticBinary); //special - case + String2MRInstructionType.put( "&&" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "||" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "xor" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "+*" , MRType.ArithmeticBinary2); + String2MRInstructionType.put( "-*" , MRType.ArithmeticBinary2); - String2MRInstructionType.put( "map+" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "map-" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "map*" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "map/" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "map%%" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "map%/%" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "map1-*" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "map^" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "mapmax" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "mapmin" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "map>" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "map>=" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "map<" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "map<=" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "map==" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "map!=" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "map&&" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "map||" , MRINSTRUCTION_TYPE.ArithmeticBinary); - String2MRInstructionType.put( "mapxor" , MRINSTRUCTION_TYPE.ArithmeticBinary); + String2MRInstructionType.put( "map+" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "map-" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "map*" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "map/" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "map%%" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "map%/%" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "map1-*" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "map^" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "mapmax" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "mapmin" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "map>" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "map>=" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "map<" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "map<=" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "map==" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "map!=" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "map&&" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "map||" , MRType.ArithmeticBinary); + String2MRInstructionType.put( "mapxor" , MRType.ArithmeticBinary); - String2MRInstructionType.put( "uaggouterchain", MRINSTRUCTION_TYPE.UaggOuterChain); + String2MRInstructionType.put( "uaggouterchain", MRType.UaggOuterChain); // REORG Instruction Opcodes - String2MRInstructionType.put( "r'" , MRINSTRUCTION_TYPE.Reorg); - String2MRInstructionType.put( "rev" , MRINSTRUCTION_TYPE.Reorg); - String2MRInstructionType.put( "rdiag" , MRINSTRUCTION_TYPE.Reorg); + String2MRInstructionType.put( "r'" , MRType.Reorg); + String2MRInstructionType.put( "rev" , MRType.Reorg); + String2MRInstructionType.put( "rdiag" , MRType.Reorg); // REPLICATE Instruction Opcodes - String2MRInstructionType.put( "rep" , MRINSTRUCTION_TYPE.Replicate); + String2MRInstructionType.put( "rep" , MRType.Replicate); // DataGen Instruction Opcodes - String2MRInstructionType.put( DataGen.RAND_OPCODE , MRINSTRUCTION_TYPE.Rand); - String2MRInstructionType.put( DataGen.SEQ_OPCODE , MRINSTRUCTION_TYPE.Seq); + String2MRInstructionType.put( DataGen.RAND_OPCODE , MRType.Rand); + String2MRInstructionType.put( DataGen.SEQ_OPCODE , MRType.Seq); // REBLOCK Instruction Opcodes - String2MRInstructionType.put( "rblk" , MRINSTRUCTION_TYPE.Reblock); - String2MRInstructionType.put( "csvrblk", MRINSTRUCTION_TYPE.CSVReblock); + String2MRInstructionType.put( "rblk" , MRType.Reblock); + String2MRInstructionType.put( "csvrblk", MRType.CSVReblock); // Ternary Reorg Instruction Opcodes - String2MRInstructionType.put( "ctabletransform", MRINSTRUCTION_TYPE.Ternary); - String2MRInstructionType.put( "ctabletransformscalarweight", MRINSTRUCTION_TYPE.Ternary); - String2MRInstructionType.put( "ctableexpandscalarweight", MRINSTRUCTION_TYPE.Ternary); - String2MRInstructionType.put( "ctabletransformhistogram", MRINSTRUCTION_TYPE.Ternary); - String2MRInstructionType.put( "ctabletransformweightedhistogram", MRINSTRUCTION_TYPE.Ternary); + String2MRInstructionType.put( "ctabletransform", MRType.Ternary); + String2MRInstructionType.put( "ctabletransformscalarweight", MRType.Ternary); + String2MRInstructionType.put( "ctableexpandscalarweight", MRType.Ternary); + String2MRInstructionType.put( "ctabletransformhistogram", MRType.Ternary); + String2MRInstructionType.put( "ctabletransformweightedhistogram", MRType.Ternary); // Quaternary Instruction Opcodes - String2MRInstructionType.put( WeightedSquaredLoss.OPCODE, MRINSTRUCTION_TYPE.Quaternary); - String2MRInstructionType.put( WeightedSquaredLossR.OPCODE, MRINSTRUCTION_TYPE.Quaternary); - String2MRInstructionType.put( WeightedSigmoid.OPCODE, MRINSTRUCTION_TYPE.Quaternary); - String2MRInstructionType.put( WeightedSigmoidR.OPCODE, MRINSTRUCTION_TYPE.Quaternary); - String2MRInstructionType.put( WeightedDivMM.OPCODE, MRINSTRUCTION_TYPE.Quaternary); - String2MRInstructionType.put( WeightedDivMMR.OPCODE, MRINSTRUCTION_TYPE.Quaternary); - String2MRInstructionType.put( WeightedCrossEntropy.OPCODE, MRINSTRUCTION_TYPE.Quaternary); - String2MRInstructionType.put( WeightedCrossEntropyR.OPCODE,MRINSTRUCTION_TYPE.Quaternary); - String2MRInstructionType.put( WeightedUnaryMM.OPCODE, MRINSTRUCTION_TYPE.Quaternary); - String2MRInstructionType.put( WeightedUnaryMMR.OPCODE, MRINSTRUCTION_TYPE.Quaternary); + String2MRInstructionType.put( WeightedSquaredLoss.OPCODE, MRType.Quaternary); + String2MRInstructionType.put( WeightedSquaredLossR.OPCODE, MRType.Quaternary); + String2MRInstructionType.put( WeightedSigmoid.OPCODE, MRType.Quaternary); + String2MRInstructionType.put( WeightedSigmoidR.OPCODE, MRType.Quaternary); + String2MRInstructionType.put( WeightedDivMM.OPCODE, MRType.Quaternary); + String2MRInstructionType.put( WeightedDivMMR.OPCODE, MRType.Quaternary); + String2MRInstructionType.put( WeightedCrossEntropy.OPCODE, MRType.Quaternary); + String2MRInstructionType.put( WeightedCrossEntropyR.OPCODE,MRType.Quaternary); + String2MRInstructionType.put( WeightedUnaryMM.OPCODE, MRType.Quaternary); + String2MRInstructionType.put( WeightedUnaryMMR.OPCODE, MRType.Quaternary); // Combine Instruction Opcodes - String2MRInstructionType.put( "combinebinary" , MRINSTRUCTION_TYPE.CombineBinary); - String2MRInstructionType.put( "combineunary" , MRINSTRUCTION_TYPE.CombineUnary); - String2MRInstructionType.put( "combineternary" , MRINSTRUCTION_TYPE.CombineTernary); + String2MRInstructionType.put( "combinebinary" , MRType.CombineBinary); + String2MRInstructionType.put( "combineunary" , MRType.CombineUnary); + String2MRInstructionType.put( "combineternary" , MRType.CombineTernary); // PickByCount Instruction Opcodes - String2MRInstructionType.put( "valuepick" , MRINSTRUCTION_TYPE.PickByCount); // for quantile() - String2MRInstructionType.put( "rangepick" , MRINSTRUCTION_TYPE.PickByCount); // for interQuantile() + String2MRInstructionType.put( "valuepick" , MRType.PickByCount); // for quantile() + String2MRInstructionType.put( "rangepick" , MRType.PickByCount); // for interQuantile() // CM Instruction Opcodes - String2MRInstructionType.put( "cm" , MRINSTRUCTION_TYPE.CM_N_COV); - String2MRInstructionType.put( "cov" , MRINSTRUCTION_TYPE.CM_N_COV); - String2MRInstructionType.put( "mean" , MRINSTRUCTION_TYPE.CM_N_COV); + String2MRInstructionType.put( "cm" , MRType.CM_N_COV); + String2MRInstructionType.put( "cov" , MRType.CM_N_COV); + String2MRInstructionType.put( "mean" , MRType.CM_N_COV); //groupedAgg Instruction Opcodes - String2MRInstructionType.put( "groupedagg" , MRINSTRUCTION_TYPE.GroupedAggregate); - String2MRInstructionType.put( "mapgroupedagg" , MRINSTRUCTION_TYPE.MapGroupedAggregate); + String2MRInstructionType.put( "groupedagg" , MRType.GroupedAggregate); + String2MRInstructionType.put( "mapgroupedagg" , MRType.MapGroupedAggregate); //right indexing - String2MRInstructionType.put( RightIndex.OPCODE , MRINSTRUCTION_TYPE.RightIndex); - String2MRInstructionType.put( RightIndex.OPCODE+"ForLeft" , MRINSTRUCTION_TYPE.RightIndex); - String2MRInstructionType.put( "zeroOut" , MRINSTRUCTION_TYPE.ZeroOut); + String2MRInstructionType.put( RightIndex.OPCODE , MRType.RightIndex); + String2MRInstructionType.put( RightIndex.OPCODE+"ForLeft" , MRType.RightIndex); + String2MRInstructionType.put( "zeroOut" , MRType.ZeroOut); //append - String2MRInstructionType.put( "mappend" , MRINSTRUCTION_TYPE.Append); - String2MRInstructionType.put( "rappend" , MRINSTRUCTION_TYPE.Append); - String2MRInstructionType.put( "gappend" , MRINSTRUCTION_TYPE.Append); + String2MRInstructionType.put( "mappend" , MRType.Append); + String2MRInstructionType.put( "rappend" , MRType.Append); + String2MRInstructionType.put( "gappend" , MRType.Append); //misc - String2MRInstructionType.put( "rshape", MRINSTRUCTION_TYPE.MatrixReshape); + String2MRInstructionType.put( "rshape", MRType.MatrixReshape); //partitioning - String2MRInstructionType.put( "partition", MRINSTRUCTION_TYPE.Partition); + String2MRInstructionType.put( "partition", MRType.Partition); //cumsum/cumprod/cummin/cummax - String2MRInstructionType.put( "ucumack+" , MRINSTRUCTION_TYPE.CumsumAggregate); - String2MRInstructionType.put( "ucumac*" , MRINSTRUCTION_TYPE.CumsumAggregate); - String2MRInstructionType.put( "ucumacmin" , MRINSTRUCTION_TYPE.CumsumAggregate); - String2MRInstructionType.put( "ucumacmax" , MRINSTRUCTION_TYPE.CumsumAggregate); - String2MRInstructionType.put( "ucumsplit" , MRINSTRUCTION_TYPE.CumsumSplit); - String2MRInstructionType.put( "bcumoffk+" , MRINSTRUCTION_TYPE.CumsumOffset); - String2MRInstructionType.put( "bcumoff*" , MRINSTRUCTION_TYPE.CumsumOffset); - String2MRInstructionType.put( "bcumoffmin", MRINSTRUCTION_TYPE.CumsumOffset); - String2MRInstructionType.put( "bcumoffmax", MRINSTRUCTION_TYPE.CumsumOffset); + String2MRInstructionType.put( "ucumack+" , MRType.CumsumAggregate); + String2MRInstructionType.put( "ucumac*" , MRType.CumsumAggregate); + String2MRInstructionType.put( "ucumacmin" , MRType.CumsumAggregate); + String2MRInstructionType.put( "ucumacmax" , MRType.CumsumAggregate); + String2MRInstructionType.put( "ucumsplit" , MRType.CumsumSplit); + String2MRInstructionType.put( "bcumoffk+" , MRType.CumsumOffset); + String2MRInstructionType.put( "bcumoff*" , MRType.CumsumOffset); + String2MRInstructionType.put( "bcumoffmin", MRType.CumsumOffset); + String2MRInstructionType.put( "bcumoffmax", MRType.CumsumOffset); //dummy (pseudo instructions) - String2MRInstructionType.put( "sort", MRINSTRUCTION_TYPE.Sort); - String2MRInstructionType.put( "csvwrite", MRINSTRUCTION_TYPE.CSVWrite); + String2MRInstructionType.put( "sort", MRType.Sort); + String2MRInstructionType.put( "csvwrite", MRType.CSVWrite); //parameterized builtins - String2MRInstructionType.put( "replace", MRINSTRUCTION_TYPE.ParameterizedBuiltin); - String2MRInstructionType.put( "rexpand", MRINSTRUCTION_TYPE.ParameterizedBuiltin); + String2MRInstructionType.put( "replace", MRType.ParameterizedBuiltin); + String2MRInstructionType.put( "rexpand", MRType.ParameterizedBuiltin); //remove empty (special type since binary not unary) - String2MRInstructionType.put( "rmempty", MRINSTRUCTION_TYPE.RemoveEmpty); + String2MRInstructionType.put( "rmempty", MRType.RemoveEmpty); } @@ -311,11 +311,11 @@ public class MRInstructionParser extends InstructionParser if ( str == null || str.isEmpty() ) return null; - MRINSTRUCTION_TYPE mrtype = InstructionUtils.getMRType(str); + MRType mrtype = InstructionUtils.getMRType(str); return parseSingleInstruction(mrtype, str); } - public static MRInstruction parseSingleInstruction (MRINSTRUCTION_TYPE mrtype, String str ) + public static MRInstruction parseSingleInstruction (MRType mrtype, String str ) throws DMLRuntimeException { if ( str == null || str.isEmpty() ) @@ -456,8 +456,6 @@ public class MRInstructionParser extends InstructionParser case CumsumOffset: return CumulativeOffsetInstruction.parseInstruction(str); - case INVALID: - default: throw new DMLRuntimeException("Invalid MR Instruction Type: " + mrtype ); } @@ -582,10 +580,10 @@ public class MRInstructionParser extends InstructionParser for(int i=0; i < strlist.length; i++) { - MRINSTRUCTION_TYPE type = InstructionUtils.getMRType(strlist[i]); - if(type==MRINSTRUCTION_TYPE.CombineBinary) + MRType type = InstructionUtils.getMRType(strlist[i]); + if(type==MRType.CombineBinary) inst[i] = (CombineBinaryInstruction) CombineBinaryInstruction.parseInstruction( strlist[i] ); - else if(type==MRINSTRUCTION_TYPE.CombineTernary) + else if(type==MRType.CombineTernary) inst[i] = (CombineTernaryInstruction)CombineTernaryInstruction.parseInstruction(strlist[i]); else throw new DMLRuntimeException("unknown combine instruction: "+strlist[i]); http://git-wip-us.apache.org/repos/asf/systemml/blob/4d1ee8e1/src/main/java/org/apache/sysml/runtime/instructions/SPInstructionParser.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/instructions/SPInstructionParser.java b/src/main/java/org/apache/sysml/runtime/instructions/SPInstructionParser.java index a45c8a0..703e585 100644 --- a/src/main/java/org/apache/sysml/runtime/instructions/SPInstructionParser.java +++ b/src/main/java/org/apache/sysml/runtime/instructions/SPInstructionParser.java @@ -75,7 +75,7 @@ import org.apache.sysml.runtime.instructions.spark.RelationalBinarySPInstruction import org.apache.sysml.runtime.instructions.spark.ReorgSPInstruction; import org.apache.sysml.runtime.instructions.spark.RmmSPInstruction; import org.apache.sysml.runtime.instructions.spark.SPInstruction; -import org.apache.sysml.runtime.instructions.spark.SPInstruction.SPINSTRUCTION_TYPE; +import org.apache.sysml.runtime.instructions.spark.SPInstruction.SPType; import org.apache.sysml.runtime.instructions.spark.SpoofSPInstruction; import org.apache.sysml.runtime.instructions.spark.TernarySPInstruction; import org.apache.sysml.runtime.instructions.spark.Tsmm2SPInstruction; @@ -88,219 +88,219 @@ import org.apache.sysml.runtime.instructions.spark.ZipmmSPInstruction; public class SPInstructionParser extends InstructionParser { - public static final HashMap<String, SPINSTRUCTION_TYPE> String2SPInstructionType; + public static final HashMap<String, SPType> String2SPInstructionType; static { String2SPInstructionType = new HashMap<>(); //unary aggregate operators - String2SPInstructionType.put( "uak+" , SPINSTRUCTION_TYPE.AggregateUnary); - String2SPInstructionType.put( "uark+" , SPINSTRUCTION_TYPE.AggregateUnary); - String2SPInstructionType.put( "uack+" , SPINSTRUCTION_TYPE.AggregateUnary); - String2SPInstructionType.put( "uasqk+" , SPINSTRUCTION_TYPE.AggregateUnary); - String2SPInstructionType.put( "uarsqk+" , SPINSTRUCTION_TYPE.AggregateUnary); - String2SPInstructionType.put( "uacsqk+" , SPINSTRUCTION_TYPE.AggregateUnary); - String2SPInstructionType.put( "uamean" , SPINSTRUCTION_TYPE.AggregateUnary); - String2SPInstructionType.put( "uarmean" , SPINSTRUCTION_TYPE.AggregateUnary); - String2SPInstructionType.put( "uacmean" , SPINSTRUCTION_TYPE.AggregateUnary); - String2SPInstructionType.put( "uavar" , SPINSTRUCTION_TYPE.AggregateUnary); - String2SPInstructionType.put( "uarvar" , SPINSTRUCTION_TYPE.AggregateUnary); - String2SPInstructionType.put( "uacvar" , SPINSTRUCTION_TYPE.AggregateUnary); - String2SPInstructionType.put( "uamax" , SPINSTRUCTION_TYPE.AggregateUnary); - String2SPInstructionType.put( "uarmax" , SPINSTRUCTION_TYPE.AggregateUnary); - String2SPInstructionType.put( "uarimax", SPINSTRUCTION_TYPE.AggregateUnary); - String2SPInstructionType.put( "uacmax" , SPINSTRUCTION_TYPE.AggregateUnary); - String2SPInstructionType.put( "uamin" , SPINSTRUCTION_TYPE.AggregateUnary); - String2SPInstructionType.put( "uarmin" , SPINSTRUCTION_TYPE.AggregateUnary); - String2SPInstructionType.put( "uarimin" , SPINSTRUCTION_TYPE.AggregateUnary); - String2SPInstructionType.put( "uacmin" , SPINSTRUCTION_TYPE.AggregateUnary); - String2SPInstructionType.put( "ua+" , SPINSTRUCTION_TYPE.AggregateUnary); - String2SPInstructionType.put( "uar+" , SPINSTRUCTION_TYPE.AggregateUnary); - String2SPInstructionType.put( "uac+" , SPINSTRUCTION_TYPE.AggregateUnary); - String2SPInstructionType.put( "ua*" , SPINSTRUCTION_TYPE.AggregateUnary); - String2SPInstructionType.put( "uatrace" , SPINSTRUCTION_TYPE.AggregateUnary); - String2SPInstructionType.put( "uaktrace", SPINSTRUCTION_TYPE.AggregateUnary); + String2SPInstructionType.put( "uak+" , SPType.AggregateUnary); + String2SPInstructionType.put( "uark+" , SPType.AggregateUnary); + String2SPInstructionType.put( "uack+" , SPType.AggregateUnary); + String2SPInstructionType.put( "uasqk+" , SPType.AggregateUnary); + String2SPInstructionType.put( "uarsqk+" , SPType.AggregateUnary); + String2SPInstructionType.put( "uacsqk+" , SPType.AggregateUnary); + String2SPInstructionType.put( "uamean" , SPType.AggregateUnary); + String2SPInstructionType.put( "uarmean" , SPType.AggregateUnary); + String2SPInstructionType.put( "uacmean" , SPType.AggregateUnary); + String2SPInstructionType.put( "uavar" , SPType.AggregateUnary); + String2SPInstructionType.put( "uarvar" , SPType.AggregateUnary); + String2SPInstructionType.put( "uacvar" , SPType.AggregateUnary); + String2SPInstructionType.put( "uamax" , SPType.AggregateUnary); + String2SPInstructionType.put( "uarmax" , SPType.AggregateUnary); + String2SPInstructionType.put( "uarimax", SPType.AggregateUnary); + String2SPInstructionType.put( "uacmax" , SPType.AggregateUnary); + String2SPInstructionType.put( "uamin" , SPType.AggregateUnary); + String2SPInstructionType.put( "uarmin" , SPType.AggregateUnary); + String2SPInstructionType.put( "uarimin" , SPType.AggregateUnary); + String2SPInstructionType.put( "uacmin" , SPType.AggregateUnary); + String2SPInstructionType.put( "ua+" , SPType.AggregateUnary); + String2SPInstructionType.put( "uar+" , SPType.AggregateUnary); + String2SPInstructionType.put( "uac+" , SPType.AggregateUnary); + String2SPInstructionType.put( "ua*" , SPType.AggregateUnary); + String2SPInstructionType.put( "uatrace" , SPType.AggregateUnary); + String2SPInstructionType.put( "uaktrace", SPType.AggregateUnary); //binary aggregate operators (matrix multiplication operators) - String2SPInstructionType.put( "mapmm" , SPINSTRUCTION_TYPE.MAPMM); - String2SPInstructionType.put( "mapmmchain" , SPINSTRUCTION_TYPE.MAPMMCHAIN); - String2SPInstructionType.put( "tsmm" , SPINSTRUCTION_TYPE.TSMM); //single-pass tsmm - String2SPInstructionType.put( "tsmm2" , SPINSTRUCTION_TYPE.TSMM2); //multi-pass tsmm - String2SPInstructionType.put( "cpmm" , SPINSTRUCTION_TYPE.CPMM); - String2SPInstructionType.put( "rmm" , SPINSTRUCTION_TYPE.RMM); - String2SPInstructionType.put( "pmm" , SPINSTRUCTION_TYPE.PMM); - String2SPInstructionType.put( "zipmm" , SPINSTRUCTION_TYPE.ZIPMM); - String2SPInstructionType.put( "pmapmm" , SPINSTRUCTION_TYPE.PMAPMM); + String2SPInstructionType.put( "mapmm" , SPType.MAPMM); + String2SPInstructionType.put( "mapmmchain" , SPType.MAPMMCHAIN); + String2SPInstructionType.put( "tsmm" , SPType.TSMM); //single-pass tsmm + String2SPInstructionType.put( "tsmm2" , SPType.TSMM2); //multi-pass tsmm + String2SPInstructionType.put( "cpmm" , SPType.CPMM); + String2SPInstructionType.put( "rmm" , SPType.RMM); + String2SPInstructionType.put( "pmm" , SPType.PMM); + String2SPInstructionType.put( "zipmm" , SPType.ZIPMM); + String2SPInstructionType.put( "pmapmm" , SPType.PMAPMM); - String2SPInstructionType.put( "uaggouterchain", SPINSTRUCTION_TYPE.UaggOuterChain); + String2SPInstructionType.put( "uaggouterchain", SPType.UaggOuterChain); //ternary aggregate operators - String2SPInstructionType.put( "tak+*" , SPINSTRUCTION_TYPE.AggregateTernary); - String2SPInstructionType.put( "tack+*" , SPINSTRUCTION_TYPE.AggregateTernary); + String2SPInstructionType.put( "tak+*" , SPType.AggregateTernary); + String2SPInstructionType.put( "tack+*" , SPType.AggregateTernary); // Neural network operators - String2SPInstructionType.put( "conv2d", SPINSTRUCTION_TYPE.Convolution); - String2SPInstructionType.put( "conv2d_bias_add", SPINSTRUCTION_TYPE.Convolution); - String2SPInstructionType.put( "maxpooling", SPINSTRUCTION_TYPE.Convolution); - String2SPInstructionType.put( "relu_maxpooling", SPINSTRUCTION_TYPE.Convolution); + String2SPInstructionType.put( "conv2d", SPType.Convolution); + String2SPInstructionType.put( "conv2d_bias_add", SPType.Convolution); + String2SPInstructionType.put( "maxpooling", SPType.Convolution); + String2SPInstructionType.put( "relu_maxpooling", SPType.Convolution); - String2SPInstructionType.put( RightIndex.OPCODE, SPINSTRUCTION_TYPE.MatrixIndexing); - String2SPInstructionType.put( LeftIndex.OPCODE, SPINSTRUCTION_TYPE.MatrixIndexing); - String2SPInstructionType.put( "mapLeftIndex" , SPINSTRUCTION_TYPE.MatrixIndexing); + String2SPInstructionType.put( RightIndex.OPCODE, SPType.MatrixIndexing); + String2SPInstructionType.put( LeftIndex.OPCODE, SPType.MatrixIndexing); + String2SPInstructionType.put( "mapLeftIndex" , SPType.MatrixIndexing); // Reorg Instruction Opcodes (repositioning of existing values) - String2SPInstructionType.put( "r'" , SPINSTRUCTION_TYPE.Reorg); - String2SPInstructionType.put( "rev" , SPINSTRUCTION_TYPE.Reorg); - String2SPInstructionType.put( "rdiag" , SPINSTRUCTION_TYPE.Reorg); - String2SPInstructionType.put( "rshape" , SPINSTRUCTION_TYPE.MatrixReshape); - String2SPInstructionType.put( "rsort" , SPINSTRUCTION_TYPE.Reorg); + String2SPInstructionType.put( "r'" , SPType.Reorg); + String2SPInstructionType.put( "rev" , SPType.Reorg); + String2SPInstructionType.put( "rdiag" , SPType.Reorg); + String2SPInstructionType.put( "rshape" , SPType.MatrixReshape); + String2SPInstructionType.put( "rsort" , SPType.Reorg); - String2SPInstructionType.put( "+" , SPINSTRUCTION_TYPE.ArithmeticBinary); - String2SPInstructionType.put( "-" , SPINSTRUCTION_TYPE.ArithmeticBinary); - String2SPInstructionType.put( "*" , SPINSTRUCTION_TYPE.ArithmeticBinary); - String2SPInstructionType.put( "/" , SPINSTRUCTION_TYPE.ArithmeticBinary); - String2SPInstructionType.put( "%%" , SPINSTRUCTION_TYPE.ArithmeticBinary); - String2SPInstructionType.put( "%/%" , SPINSTRUCTION_TYPE.ArithmeticBinary); - String2SPInstructionType.put( "1-*" , SPINSTRUCTION_TYPE.ArithmeticBinary); - String2SPInstructionType.put( "^" , SPINSTRUCTION_TYPE.ArithmeticBinary); - String2SPInstructionType.put( "^2" , SPINSTRUCTION_TYPE.ArithmeticBinary); - String2SPInstructionType.put( "*2" , SPINSTRUCTION_TYPE.ArithmeticBinary); - String2SPInstructionType.put( "+*" , SPINSTRUCTION_TYPE.ArithmeticBinary); - String2SPInstructionType.put( "-*" , SPINSTRUCTION_TYPE.ArithmeticBinary); - String2SPInstructionType.put( "map+" , SPINSTRUCTION_TYPE.ArithmeticBinary); - String2SPInstructionType.put( "map-" , SPINSTRUCTION_TYPE.ArithmeticBinary); - String2SPInstructionType.put( "map*" , SPINSTRUCTION_TYPE.ArithmeticBinary); - String2SPInstructionType.put( "map/" , SPINSTRUCTION_TYPE.ArithmeticBinary); - String2SPInstructionType.put( "map%%" , SPINSTRUCTION_TYPE.ArithmeticBinary); - String2SPInstructionType.put( "map%/%" , SPINSTRUCTION_TYPE.ArithmeticBinary); - String2SPInstructionType.put( "map1-*" , SPINSTRUCTION_TYPE.ArithmeticBinary); - String2SPInstructionType.put( "map^" , SPINSTRUCTION_TYPE.ArithmeticBinary); - String2SPInstructionType.put( "map+*" , SPINSTRUCTION_TYPE.ArithmeticBinary); - String2SPInstructionType.put( "map-*" , SPINSTRUCTION_TYPE.ArithmeticBinary); + String2SPInstructionType.put( "+" , SPType.ArithmeticBinary); + String2SPInstructionType.put( "-" , SPType.ArithmeticBinary); + String2SPInstructionType.put( "*" , SPType.ArithmeticBinary); + String2SPInstructionType.put( "/" , SPType.ArithmeticBinary); + String2SPInstructionType.put( "%%" , SPType.ArithmeticBinary); + String2SPInstructionType.put( "%/%" , SPType.ArithmeticBinary); + String2SPInstructionType.put( "1-*" , SPType.ArithmeticBinary); + String2SPInstructionType.put( "^" , SPType.ArithmeticBinary); + String2SPInstructionType.put( "^2" , SPType.ArithmeticBinary); + String2SPInstructionType.put( "*2" , SPType.ArithmeticBinary); + String2SPInstructionType.put( "+*" , SPType.ArithmeticBinary); + String2SPInstructionType.put( "-*" , SPType.ArithmeticBinary); + String2SPInstructionType.put( "map+" , SPType.ArithmeticBinary); + String2SPInstructionType.put( "map-" , SPType.ArithmeticBinary); + String2SPInstructionType.put( "map*" , SPType.ArithmeticBinary); + String2SPInstructionType.put( "map/" , SPType.ArithmeticBinary); + String2SPInstructionType.put( "map%%" , SPType.ArithmeticBinary); + String2SPInstructionType.put( "map%/%" , SPType.ArithmeticBinary); + String2SPInstructionType.put( "map1-*" , SPType.ArithmeticBinary); + String2SPInstructionType.put( "map^" , SPType.ArithmeticBinary); + String2SPInstructionType.put( "map+*" , SPType.ArithmeticBinary); + String2SPInstructionType.put( "map-*" , SPType.ArithmeticBinary); // Relational Instruction Opcodes - String2SPInstructionType.put( "==" , SPINSTRUCTION_TYPE.RelationalBinary); - String2SPInstructionType.put( "!=" , SPINSTRUCTION_TYPE.RelationalBinary); - String2SPInstructionType.put( "<" , SPINSTRUCTION_TYPE.RelationalBinary); - String2SPInstructionType.put( ">" , SPINSTRUCTION_TYPE.RelationalBinary); - String2SPInstructionType.put( "<=" , SPINSTRUCTION_TYPE.RelationalBinary); - String2SPInstructionType.put( ">=" , SPINSTRUCTION_TYPE.RelationalBinary); - String2SPInstructionType.put( "map>" , SPINSTRUCTION_TYPE.RelationalBinary); - String2SPInstructionType.put( "map>=" , SPINSTRUCTION_TYPE.RelationalBinary); - String2SPInstructionType.put( "map<" , SPINSTRUCTION_TYPE.RelationalBinary); - String2SPInstructionType.put( "map<=" , SPINSTRUCTION_TYPE.RelationalBinary); - String2SPInstructionType.put( "map==" , SPINSTRUCTION_TYPE.RelationalBinary); - String2SPInstructionType.put( "map!=" , SPINSTRUCTION_TYPE.RelationalBinary); + String2SPInstructionType.put( "==" , SPType.RelationalBinary); + String2SPInstructionType.put( "!=" , SPType.RelationalBinary); + String2SPInstructionType.put( "<" , SPType.RelationalBinary); + String2SPInstructionType.put( ">" , SPType.RelationalBinary); + String2SPInstructionType.put( "<=" , SPType.RelationalBinary); + String2SPInstructionType.put( ">=" , SPType.RelationalBinary); + String2SPInstructionType.put( "map>" , SPType.RelationalBinary); + String2SPInstructionType.put( "map>=" , SPType.RelationalBinary); + String2SPInstructionType.put( "map<" , SPType.RelationalBinary); + String2SPInstructionType.put( "map<=" , SPType.RelationalBinary); + String2SPInstructionType.put( "map==" , SPType.RelationalBinary); + String2SPInstructionType.put( "map!=" , SPType.RelationalBinary); // Boolean Instruction Opcodes - String2SPInstructionType.put( "&&" , SPINSTRUCTION_TYPE.ArithmeticBinary); - String2SPInstructionType.put( "||" , SPINSTRUCTION_TYPE.ArithmeticBinary); - String2SPInstructionType.put( "xor" , SPINSTRUCTION_TYPE.ArithmeticBinary); - String2SPInstructionType.put( "!" , SPINSTRUCTION_TYPE.BuiltinUnary); - String2SPInstructionType.put( "map&&" , SPINSTRUCTION_TYPE.ArithmeticBinary); - String2SPInstructionType.put( "map||" , SPINSTRUCTION_TYPE.ArithmeticBinary); - String2SPInstructionType.put( "mapxor" , SPINSTRUCTION_TYPE.ArithmeticBinary); - String2SPInstructionType.put( "map!" , SPINSTRUCTION_TYPE.BuiltinUnary); + String2SPInstructionType.put( "&&" , SPType.ArithmeticBinary); + String2SPInstructionType.put( "||" , SPType.ArithmeticBinary); + String2SPInstructionType.put( "xor" , SPType.ArithmeticBinary); + String2SPInstructionType.put( "!" , SPType.BuiltinUnary); + String2SPInstructionType.put( "map&&" , SPType.ArithmeticBinary); + String2SPInstructionType.put( "map||" , SPType.ArithmeticBinary); + String2SPInstructionType.put( "mapxor" , SPType.ArithmeticBinary); + String2SPInstructionType.put( "map!" , SPType.BuiltinUnary); // REBLOCK Instruction Opcodes - String2SPInstructionType.put( "rblk" , SPINSTRUCTION_TYPE.Reblock); - String2SPInstructionType.put( "csvrblk", SPINSTRUCTION_TYPE.CSVReblock); + String2SPInstructionType.put( "rblk" , SPType.Reblock); + String2SPInstructionType.put( "csvrblk", SPType.CSVReblock); // Spark-specific instructions - String2SPInstructionType.put( Checkpoint.OPCODE, SPINSTRUCTION_TYPE.Checkpoint); - String2SPInstructionType.put( Compression.OPCODE, SPINSTRUCTION_TYPE.Compression); + String2SPInstructionType.put( Checkpoint.OPCODE, SPType.Checkpoint); + String2SPInstructionType.put( Compression.OPCODE, SPType.Compression); // Builtin Instruction Opcodes - String2SPInstructionType.put( "log" , SPINSTRUCTION_TYPE.Builtin); - String2SPInstructionType.put( "log_nz" , SPINSTRUCTION_TYPE.Builtin); + String2SPInstructionType.put( "log" , SPType.Builtin); + String2SPInstructionType.put( "log_nz" , SPType.Builtin); // Boolean Binary builtin - String2SPInstructionType.put( "max" , SPINSTRUCTION_TYPE.BuiltinBinary); - String2SPInstructionType.put( "min" , SPINSTRUCTION_TYPE.BuiltinBinary); - String2SPInstructionType.put( "mapmax" , SPINSTRUCTION_TYPE.BuiltinBinary); - String2SPInstructionType.put( "mapmin" , SPINSTRUCTION_TYPE.BuiltinBinary); + String2SPInstructionType.put( "max" , SPType.BuiltinBinary); + String2SPInstructionType.put( "min" , SPType.BuiltinBinary); + String2SPInstructionType.put( "mapmax" , SPType.BuiltinBinary); + String2SPInstructionType.put( "mapmin" , SPType.BuiltinBinary); - String2SPInstructionType.put( "exp" , SPINSTRUCTION_TYPE.BuiltinUnary); - String2SPInstructionType.put( "abs" , SPINSTRUCTION_TYPE.BuiltinUnary); - String2SPInstructionType.put( "sin" , SPINSTRUCTION_TYPE.BuiltinUnary); - String2SPInstructionType.put( "cos" , SPINSTRUCTION_TYPE.BuiltinUnary); - String2SPInstructionType.put( "tan" , SPINSTRUCTION_TYPE.BuiltinUnary); - String2SPInstructionType.put( "asin" , SPINSTRUCTION_TYPE.BuiltinUnary); - String2SPInstructionType.put( "acos" , SPINSTRUCTION_TYPE.BuiltinUnary); - String2SPInstructionType.put( "atan" , SPINSTRUCTION_TYPE.BuiltinUnary); - String2SPInstructionType.put( "sinh" , SPINSTRUCTION_TYPE.BuiltinUnary); - String2SPInstructionType.put( "cosh" , SPINSTRUCTION_TYPE.BuiltinUnary); - String2SPInstructionType.put( "tanh" , SPINSTRUCTION_TYPE.BuiltinUnary); - String2SPInstructionType.put( "sign" , SPINSTRUCTION_TYPE.BuiltinUnary); - String2SPInstructionType.put( "sqrt" , SPINSTRUCTION_TYPE.BuiltinUnary); - String2SPInstructionType.put( "plogp" , SPINSTRUCTION_TYPE.BuiltinUnary); - String2SPInstructionType.put( "round" , SPINSTRUCTION_TYPE.BuiltinUnary); - String2SPInstructionType.put( "ceil" , SPINSTRUCTION_TYPE.BuiltinUnary); - String2SPInstructionType.put( "floor" , SPINSTRUCTION_TYPE.BuiltinUnary); - String2SPInstructionType.put( "sprop", SPINSTRUCTION_TYPE.BuiltinUnary); - String2SPInstructionType.put( "sigmoid", SPINSTRUCTION_TYPE.BuiltinUnary); - String2SPInstructionType.put( "sel+", SPINSTRUCTION_TYPE.BuiltinUnary); + String2SPInstructionType.put( "exp" , SPType.BuiltinUnary); + String2SPInstructionType.put( "abs" , SPType.BuiltinUnary); + String2SPInstructionType.put( "sin" , SPType.BuiltinUnary); + String2SPInstructionType.put( "cos" , SPType.BuiltinUnary); + String2SPInstructionType.put( "tan" , SPType.BuiltinUnary); + String2SPInstructionType.put( "asin" , SPType.BuiltinUnary); + String2SPInstructionType.put( "acos" , SPType.BuiltinUnary); + String2SPInstructionType.put( "atan" , SPType.BuiltinUnary); + String2SPInstructionType.put( "sinh" , SPType.BuiltinUnary); + String2SPInstructionType.put( "cosh" , SPType.BuiltinUnary); + String2SPInstructionType.put( "tanh" , SPType.BuiltinUnary); + String2SPInstructionType.put( "sign" , SPType.BuiltinUnary); + String2SPInstructionType.put( "sqrt" , SPType.BuiltinUnary); + String2SPInstructionType.put( "plogp" , SPType.BuiltinUnary); + String2SPInstructionType.put( "round" , SPType.BuiltinUnary); + String2SPInstructionType.put( "ceil" , SPType.BuiltinUnary); + String2SPInstructionType.put( "floor" , SPType.BuiltinUnary); + String2SPInstructionType.put( "sprop", SPType.BuiltinUnary); + String2SPInstructionType.put( "sigmoid", SPType.BuiltinUnary); + String2SPInstructionType.put( "sel+", SPType.BuiltinUnary); // Parameterized Builtin Functions - String2SPInstructionType.put( "groupedagg" , SPINSTRUCTION_TYPE.ParameterizedBuiltin); - String2SPInstructionType.put( "mapgroupedagg", SPINSTRUCTION_TYPE.ParameterizedBuiltin); - String2SPInstructionType.put( "rmempty" , SPINSTRUCTION_TYPE.ParameterizedBuiltin); - String2SPInstructionType.put( "replace" , SPINSTRUCTION_TYPE.ParameterizedBuiltin); - String2SPInstructionType.put( "rexpand" , SPINSTRUCTION_TYPE.ParameterizedBuiltin); - String2SPInstructionType.put( "transformapply",SPINSTRUCTION_TYPE.ParameterizedBuiltin); - String2SPInstructionType.put( "transformdecode",SPINSTRUCTION_TYPE.ParameterizedBuiltin); - String2SPInstructionType.put( "transformencode",SPINSTRUCTION_TYPE.MultiReturnBuiltin); + String2SPInstructionType.put( "groupedagg" , SPType.ParameterizedBuiltin); + String2SPInstructionType.put( "mapgroupedagg", SPType.ParameterizedBuiltin); + String2SPInstructionType.put( "rmempty" , SPType.ParameterizedBuiltin); + String2SPInstructionType.put( "replace" , SPType.ParameterizedBuiltin); + String2SPInstructionType.put( "rexpand" , SPType.ParameterizedBuiltin); + String2SPInstructionType.put( "transformapply",SPType.ParameterizedBuiltin); + String2SPInstructionType.put( "transformdecode",SPType.ParameterizedBuiltin); + String2SPInstructionType.put( "transformencode",SPType.MultiReturnBuiltin); - String2SPInstructionType.put( "mappend", SPINSTRUCTION_TYPE.MAppend); - String2SPInstructionType.put( "rappend", SPINSTRUCTION_TYPE.RAppend); - String2SPInstructionType.put( "gappend", SPINSTRUCTION_TYPE.GAppend); - String2SPInstructionType.put( "galignedappend", SPINSTRUCTION_TYPE.GAlignedAppend); - String2SPInstructionType.put( "cbind", SPINSTRUCTION_TYPE.BuiltinNary); - String2SPInstructionType.put( "rbind", SPINSTRUCTION_TYPE.BuiltinNary); + String2SPInstructionType.put( "mappend", SPType.MAppend); + String2SPInstructionType.put( "rappend", SPType.RAppend); + String2SPInstructionType.put( "gappend", SPType.GAppend); + String2SPInstructionType.put( "galignedappend", SPType.GAlignedAppend); + String2SPInstructionType.put( "cbind", SPType.BuiltinNary); + String2SPInstructionType.put( "rbind", SPType.BuiltinNary); - String2SPInstructionType.put( DataGen.RAND_OPCODE , SPINSTRUCTION_TYPE.Rand); - String2SPInstructionType.put( DataGen.SEQ_OPCODE , SPINSTRUCTION_TYPE.Rand); - String2SPInstructionType.put( DataGen.SAMPLE_OPCODE, SPINSTRUCTION_TYPE.Rand); + String2SPInstructionType.put( DataGen.RAND_OPCODE , SPType.Rand); + String2SPInstructionType.put( DataGen.SEQ_OPCODE , SPType.Rand); + String2SPInstructionType.put( DataGen.SAMPLE_OPCODE, SPType.Rand); //ternary instruction opcodes - String2SPInstructionType.put( "ctable", SPINSTRUCTION_TYPE.Ternary); - String2SPInstructionType.put( "ctableexpand", SPINSTRUCTION_TYPE.Ternary); + String2SPInstructionType.put( "ctable", SPType.Ternary); + String2SPInstructionType.put( "ctableexpand", SPType.Ternary); //quaternary instruction opcodes - String2SPInstructionType.put( WeightedSquaredLoss.OPCODE, SPINSTRUCTION_TYPE.Quaternary); - String2SPInstructionType.put( WeightedSquaredLossR.OPCODE, SPINSTRUCTION_TYPE.Quaternary); - String2SPInstructionType.put( WeightedSigmoid.OPCODE, SPINSTRUCTION_TYPE.Quaternary); - String2SPInstructionType.put( WeightedSigmoidR.OPCODE, SPINSTRUCTION_TYPE.Quaternary); - String2SPInstructionType.put( WeightedDivMM.OPCODE, SPINSTRUCTION_TYPE.Quaternary); - String2SPInstructionType.put( WeightedDivMMR.OPCODE, SPINSTRUCTION_TYPE.Quaternary); - String2SPInstructionType.put( WeightedCrossEntropy.OPCODE, SPINSTRUCTION_TYPE.Quaternary); - String2SPInstructionType.put( WeightedCrossEntropyR.OPCODE,SPINSTRUCTION_TYPE.Quaternary); - String2SPInstructionType.put( WeightedUnaryMM.OPCODE, SPINSTRUCTION_TYPE.Quaternary); - String2SPInstructionType.put( WeightedUnaryMMR.OPCODE, SPINSTRUCTION_TYPE.Quaternary); + String2SPInstructionType.put( WeightedSquaredLoss.OPCODE, SPType.Quaternary); + String2SPInstructionType.put( WeightedSquaredLossR.OPCODE, SPType.Quaternary); + String2SPInstructionType.put( WeightedSigmoid.OPCODE, SPType.Quaternary); + String2SPInstructionType.put( WeightedSigmoidR.OPCODE, SPType.Quaternary); + String2SPInstructionType.put( WeightedDivMM.OPCODE, SPType.Quaternary); + String2SPInstructionType.put( WeightedDivMMR.OPCODE, SPType.Quaternary); + String2SPInstructionType.put( WeightedCrossEntropy.OPCODE, SPType.Quaternary); + String2SPInstructionType.put( WeightedCrossEntropyR.OPCODE,SPType.Quaternary); + String2SPInstructionType.put( WeightedUnaryMM.OPCODE, SPType.Quaternary); + String2SPInstructionType.put( WeightedUnaryMMR.OPCODE, SPType.Quaternary); //cumsum/cumprod/cummin/cummax - String2SPInstructionType.put( "ucumack+" , SPINSTRUCTION_TYPE.CumsumAggregate); - String2SPInstructionType.put( "ucumac*" , SPINSTRUCTION_TYPE.CumsumAggregate); - String2SPInstructionType.put( "ucumacmin" , SPINSTRUCTION_TYPE.CumsumAggregate); - String2SPInstructionType.put( "ucumacmax" , SPINSTRUCTION_TYPE.CumsumAggregate); - String2SPInstructionType.put( "bcumoffk+" , SPINSTRUCTION_TYPE.CumsumOffset); - String2SPInstructionType.put( "bcumoff*" , SPINSTRUCTION_TYPE.CumsumOffset); - String2SPInstructionType.put( "bcumoffmin", SPINSTRUCTION_TYPE.CumsumOffset); - String2SPInstructionType.put( "bcumoffmax", SPINSTRUCTION_TYPE.CumsumOffset); + String2SPInstructionType.put( "ucumack+" , SPType.CumsumAggregate); + String2SPInstructionType.put( "ucumac*" , SPType.CumsumAggregate); + String2SPInstructionType.put( "ucumacmin" , SPType.CumsumAggregate); + String2SPInstructionType.put( "ucumacmax" , SPType.CumsumAggregate); + String2SPInstructionType.put( "bcumoffk+" , SPType.CumsumOffset); + String2SPInstructionType.put( "bcumoff*" , SPType.CumsumOffset); + String2SPInstructionType.put( "bcumoffmin", SPType.CumsumOffset); + String2SPInstructionType.put( "bcumoffmax", SPType.CumsumOffset); //central moment, covariance, quantiles (sort/pick) - String2SPInstructionType.put( "cm" , SPINSTRUCTION_TYPE.CentralMoment); - String2SPInstructionType.put( "cov" , SPINSTRUCTION_TYPE.Covariance); - String2SPInstructionType.put( "qsort" , SPINSTRUCTION_TYPE.QSort); - String2SPInstructionType.put( "qpick" , SPINSTRUCTION_TYPE.QPick); + String2SPInstructionType.put( "cm" , SPType.CentralMoment); + String2SPInstructionType.put( "cov" , SPType.Covariance); + String2SPInstructionType.put( "qsort" , SPType.QSort); + String2SPInstructionType.put( "qpick" , SPType.QPick); - String2SPInstructionType.put( "binuaggchain", SPINSTRUCTION_TYPE.BinUaggChain); + String2SPInstructionType.put( "binuaggchain", SPType.BinUaggChain); - String2SPInstructionType.put( "write" , SPINSTRUCTION_TYPE.Write); + String2SPInstructionType.put( "write" , SPType.Write); - String2SPInstructionType.put( "castdtm" , SPINSTRUCTION_TYPE.Cast); - String2SPInstructionType.put( "castdtf" , SPINSTRUCTION_TYPE.Cast); + String2SPInstructionType.put( "castdtm" , SPType.Cast); + String2SPInstructionType.put( "castdtf" , SPType.Cast); - String2SPInstructionType.put( "spoof" , SPINSTRUCTION_TYPE.SpoofFused); + String2SPInstructionType.put( "spoof" , SPType.SpoofFused); } public static SPInstruction parseSingleInstruction (String str ) @@ -309,7 +309,7 @@ public class SPInstructionParser extends InstructionParser if ( str == null || str.isEmpty() ) return null; - SPINSTRUCTION_TYPE cptype = InstructionUtils.getSPType(str); + SPType cptype = InstructionUtils.getSPType(str); if ( cptype == null ) // return null; throw new DMLRuntimeException("Invalid SP Instruction Type: " + str); @@ -319,7 +319,7 @@ public class SPInstructionParser extends InstructionParser return spinst; } - public static SPInstruction parseSingleInstruction ( SPINSTRUCTION_TYPE sptype, String str ) + public static SPInstruction parseSingleInstruction ( SPType sptype, String str ) throws DMLRuntimeException { if ( str == null || str.isEmpty() ) @@ -475,8 +475,7 @@ public class SPInstructionParser extends InstructionParser case Cast: return CastSPInstruction.parseInstruction(str); - - case INVALID: + default: throw new DMLRuntimeException("Invalid SP Instruction Type: " + sptype ); } http://git-wip-us.apache.org/repos/asf/systemml/blob/4d1ee8e1/src/main/java/org/apache/sysml/runtime/instructions/cp/CPInstruction.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/instructions/cp/CPInstruction.java b/src/main/java/org/apache/sysml/runtime/instructions/cp/CPInstruction.java index 0b27768..5a20b22 100644 --- a/src/main/java/org/apache/sysml/runtime/instructions/cp/CPInstruction.java +++ b/src/main/java/org/apache/sysml/runtime/instructions/cp/CPInstruction.java @@ -29,7 +29,7 @@ import org.apache.sysml.runtime.matrix.operators.Operator; public abstract class CPInstruction extends Instruction { - public enum CPType { INVALID, + public enum CPType { AggregateUnary, AggregateBinary, AggregateTernary, ArithmeticBinary, Ternary, Quaternary, BooleanBinary, BooleanUnary, BuiltinBinary, BuiltinUnary, BuiltinNary, MultiReturnParameterizedBuiltin, ParameterizedBuiltin, MultiReturnBuiltin, http://git-wip-us.apache.org/repos/asf/systemml/blob/4d1ee8e1/src/main/java/org/apache/sysml/runtime/instructions/mr/AggregateBinaryInstruction.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/instructions/mr/AggregateBinaryInstruction.java b/src/main/java/org/apache/sysml/runtime/instructions/mr/AggregateBinaryInstruction.java index a5a830e..2766062 100644 --- a/src/main/java/org/apache/sysml/runtime/instructions/mr/AggregateBinaryInstruction.java +++ b/src/main/java/org/apache/sysml/runtime/instructions/mr/AggregateBinaryInstruction.java @@ -50,10 +50,8 @@ public class AggregateBinaryInstruction extends BinaryMRInstructionBase implemen private boolean _outputEmptyBlocks = true; private AggregateBinaryInstruction(Operator op, String opcode, byte in1, byte in2, byte out, String istr) { - super(op, in1, in2, out); - mrtype = MRINSTRUCTION_TYPE.AggregateBinary; + super(MRType.AggregateBinary, op, in1, in2, out); instString = istr; - _opcode = opcode; } http://git-wip-us.apache.org/repos/asf/systemml/blob/4d1ee8e1/src/main/java/org/apache/sysml/runtime/instructions/mr/AggregateInstruction.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/instructions/mr/AggregateInstruction.java b/src/main/java/org/apache/sysml/runtime/instructions/mr/AggregateInstruction.java index f249f08..be924df 100644 --- a/src/main/java/org/apache/sysml/runtime/instructions/mr/AggregateInstruction.java +++ b/src/main/java/org/apache/sysml/runtime/instructions/mr/AggregateInstruction.java @@ -30,8 +30,7 @@ import org.apache.sysml.runtime.matrix.operators.Operator; public class AggregateInstruction extends UnaryMRInstructionBase { public AggregateInstruction(Operator op, byte in, byte out, String istr) { - super(op, in, out); - mrtype = MRINSTRUCTION_TYPE.Aggregate; + super(MRType.Aggregate, op, in, out); instString = istr; } http://git-wip-us.apache.org/repos/asf/systemml/blob/4d1ee8e1/src/main/java/org/apache/sysml/runtime/instructions/mr/AggregateUnaryInstruction.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/instructions/mr/AggregateUnaryInstruction.java b/src/main/java/org/apache/sysml/runtime/instructions/mr/AggregateUnaryInstruction.java index 35dfe7c..923d110 100644 --- a/src/main/java/org/apache/sysml/runtime/instructions/mr/AggregateUnaryInstruction.java +++ b/src/main/java/org/apache/sysml/runtime/instructions/mr/AggregateUnaryInstruction.java @@ -37,10 +37,8 @@ public class AggregateUnaryInstruction extends UnaryMRInstructionBase { private boolean _dropCorr = false; protected AggregateUnaryInstruction(Operator op, byte in, byte out, boolean dropCorr, String istr) { - super(op, in, out); - mrtype = MRINSTRUCTION_TYPE.AggregateUnary; + super(MRType.AggregateUnary, op, in, out); instString = istr; - _dropCorr = dropCorr; } http://git-wip-us.apache.org/repos/asf/systemml/blob/4d1ee8e1/src/main/java/org/apache/sysml/runtime/instructions/mr/AppendInstruction.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/instructions/mr/AppendInstruction.java b/src/main/java/org/apache/sysml/runtime/instructions/mr/AppendInstruction.java index a515a34..f92d62c 100644 --- a/src/main/java/org/apache/sysml/runtime/instructions/mr/AppendInstruction.java +++ b/src/main/java/org/apache/sysml/runtime/instructions/mr/AppendInstruction.java @@ -31,9 +31,8 @@ public class AppendInstruction extends BinaryMRInstructionBase { protected boolean _cbind = true; protected AppendInstruction(Operator op, byte in1, byte in2, byte out, boolean cbind, String istr) { - super(op, in1, in2, out); + super(MRType.Append, op, in1, in2, out); instString = istr; - mrtype = MRINSTRUCTION_TYPE.Append; _cbind = cbind; } http://git-wip-us.apache.org/repos/asf/systemml/blob/4d1ee8e1/src/main/java/org/apache/sysml/runtime/instructions/mr/BinUaggChainInstruction.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/instructions/mr/BinUaggChainInstruction.java b/src/main/java/org/apache/sysml/runtime/instructions/mr/BinUaggChainInstruction.java index 93674b7..90c33ff 100644 --- a/src/main/java/org/apache/sysml/runtime/instructions/mr/BinUaggChainInstruction.java +++ b/src/main/java/org/apache/sysml/runtime/instructions/mr/BinUaggChainInstruction.java @@ -41,17 +41,12 @@ public class BinUaggChainInstruction extends UnaryInstruction { private MatrixIndexes _tmpIx = null; private MatrixValue _tmpVal = null; - private BinUaggChainInstruction(BinaryOperator bop, AggregateUnaryOperator uaggop, byte in1, byte out, - String istr) { - super(null, in1, out, istr); - + private BinUaggChainInstruction(BinaryOperator bop, AggregateUnaryOperator uaggop, byte in1, byte out, String istr) { + super(MRType.BinUaggChain, null, in1, out, istr); _bOp = bop; _uaggOp = uaggop; - _tmpIx = new MatrixIndexes(); _tmpVal = new MatrixBlock(); - - mrtype = MRINSTRUCTION_TYPE.BinUaggChain; instString = istr; } http://git-wip-us.apache.org/repos/asf/systemml/blob/4d1ee8e1/src/main/java/org/apache/sysml/runtime/instructions/mr/BinaryInstruction.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/instructions/mr/BinaryInstruction.java b/src/main/java/org/apache/sysml/runtime/instructions/mr/BinaryInstruction.java index f88b2f6..e67e425 100644 --- a/src/main/java/org/apache/sysml/runtime/instructions/mr/BinaryInstruction.java +++ b/src/main/java/org/apache/sysml/runtime/instructions/mr/BinaryInstruction.java @@ -31,9 +31,8 @@ import org.apache.sysml.runtime.matrix.operators.Operator; public class BinaryInstruction extends BinaryMRInstructionBase { - protected BinaryInstruction(Operator op, byte in1, byte in2, byte out, String istr) { - super(op, in1, in2, out); - mrtype = MRINSTRUCTION_TYPE.ArithmeticBinary; + protected BinaryInstruction(MRType type, Operator op, byte in1, byte in2, byte out, String istr) { + super(type, op, in1, in2, out); instString = istr; } @@ -52,7 +51,7 @@ public class BinaryInstruction extends BinaryMRInstructionBase { BinaryOperator bop = InstructionUtils.parseBinaryOperator(opcode); if( bop != null ) - return new BinaryInstruction(bop, in1, in2, out, str); + return new BinaryInstruction(MRType.ArithmeticBinary, bop, in1, in2, out, str); else return null; } http://git-wip-us.apache.org/repos/asf/systemml/blob/4d1ee8e1/src/main/java/org/apache/sysml/runtime/instructions/mr/BinaryMInstruction.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/instructions/mr/BinaryMInstruction.java b/src/main/java/org/apache/sysml/runtime/instructions/mr/BinaryMInstruction.java index bae1786..07615e8 100644 --- a/src/main/java/org/apache/sysml/runtime/instructions/mr/BinaryMInstruction.java +++ b/src/main/java/org/apache/sysml/runtime/instructions/mr/BinaryMInstruction.java @@ -37,12 +37,9 @@ import org.apache.sysml.runtime.matrix.operators.Operator; public class BinaryMInstruction extends BinaryMRInstructionBase implements IDistributedCacheConsumer { private VectorType _vectorType = null; - private BinaryMInstruction(Operator op, byte in1, byte in2, CacheType ctype, VectorType vtype, byte out, - String istr) { - super(op, in1, in2, out); - mrtype = MRINSTRUCTION_TYPE.ArithmeticBinary; + private BinaryMInstruction(Operator op, byte in1, byte in2, CacheType ctype, VectorType vtype, byte out, String istr) { + super(MRType.ArithmeticBinary, op, in1, in2, out); instString = istr; - _vectorType = vtype; } http://git-wip-us.apache.org/repos/asf/systemml/blob/4d1ee8e1/src/main/java/org/apache/sysml/runtime/instructions/mr/BinaryMRInstructionBase.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/instructions/mr/BinaryMRInstructionBase.java b/src/main/java/org/apache/sysml/runtime/instructions/mr/BinaryMRInstructionBase.java index 5c28c43..ffd1a31 100644 --- a/src/main/java/org/apache/sysml/runtime/instructions/mr/BinaryMRInstructionBase.java +++ b/src/main/java/org/apache/sysml/runtime/instructions/mr/BinaryMRInstructionBase.java @@ -24,8 +24,8 @@ import org.apache.sysml.runtime.matrix.operators.Operator; public abstract class BinaryMRInstructionBase extends MRInstruction { public byte input1, input2; - protected BinaryMRInstructionBase(Operator op, byte in1, byte in2, byte out) { - super(op, out); + protected BinaryMRInstructionBase(MRType type, Operator op, byte in1, byte in2, byte out) { + super(type, op, out); input1 = in1; input2 = in2; } http://git-wip-us.apache.org/repos/asf/systemml/blob/4d1ee8e1/src/main/java/org/apache/sysml/runtime/instructions/mr/CM_N_COVInstruction.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/instructions/mr/CM_N_COVInstruction.java b/src/main/java/org/apache/sysml/runtime/instructions/mr/CM_N_COVInstruction.java index 0fc6df2..6c69cc2 100644 --- a/src/main/java/org/apache/sysml/runtime/instructions/mr/CM_N_COVInstruction.java +++ b/src/main/java/org/apache/sysml/runtime/instructions/mr/CM_N_COVInstruction.java @@ -34,8 +34,7 @@ import org.apache.sysml.runtime.matrix.operators.CMOperator.AggregateOperationTy public class CM_N_COVInstruction extends UnaryMRInstructionBase { private CM_N_COVInstruction(Operator op, byte in, byte out, String istr) { - super(op, in, out); - mrtype = MRINSTRUCTION_TYPE.CM_N_COV; + super(MRType.CM_N_COV, op, in, out); instString = istr; } http://git-wip-us.apache.org/repos/asf/systemml/blob/4d1ee8e1/src/main/java/org/apache/sysml/runtime/instructions/mr/CSVWriteInstruction.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/instructions/mr/CSVWriteInstruction.java b/src/main/java/org/apache/sysml/runtime/instructions/mr/CSVWriteInstruction.java index c182dca..050225b 100644 --- a/src/main/java/org/apache/sysml/runtime/instructions/mr/CSVWriteInstruction.java +++ b/src/main/java/org/apache/sysml/runtime/instructions/mr/CSVWriteInstruction.java @@ -33,8 +33,7 @@ public class CSVWriteInstruction extends UnaryMRInstructionBase { public boolean sparse = DataExpression.DEFAULT_DELIM_SPARSE; public CSVWriteInstruction(Operator op, byte in, byte out, String del, String hdr, boolean sps, String istr) { - super(op, in, out); - mrtype = MRINSTRUCTION_TYPE.CSVWrite; + super(MRType.CSVWrite, op, in, out); delim=del; header=hdr; sparse=sps; http://git-wip-us.apache.org/repos/asf/systemml/blob/4d1ee8e1/src/main/java/org/apache/sysml/runtime/instructions/mr/CombineBinaryInstruction.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/instructions/mr/CombineBinaryInstruction.java b/src/main/java/org/apache/sysml/runtime/instructions/mr/CombineBinaryInstruction.java index b18df04..2359845 100644 --- a/src/main/java/org/apache/sysml/runtime/instructions/mr/CombineBinaryInstruction.java +++ b/src/main/java/org/apache/sysml/runtime/instructions/mr/CombineBinaryInstruction.java @@ -33,9 +33,8 @@ public class CombineBinaryInstruction extends BinaryMRInstructionBase { private boolean secondInputIsWeight = true; private CombineBinaryInstruction(Operator op, boolean isWeight, byte in1, byte in2, byte out, String istr) { - super(op, in1, in2, out); + super(MRType.CombineBinary, op, in1, in2, out); secondInputIsWeight = isWeight; - mrtype = MRINSTRUCTION_TYPE.CombineBinary; instString = istr; } http://git-wip-us.apache.org/repos/asf/systemml/blob/4d1ee8e1/src/main/java/org/apache/sysml/runtime/instructions/mr/CombineTernaryInstruction.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/instructions/mr/CombineTernaryInstruction.java b/src/main/java/org/apache/sysml/runtime/instructions/mr/CombineTernaryInstruction.java index cda5c3e..4bfc94e 100644 --- a/src/main/java/org/apache/sysml/runtime/instructions/mr/CombineTernaryInstruction.java +++ b/src/main/java/org/apache/sysml/runtime/instructions/mr/CombineTernaryInstruction.java @@ -29,8 +29,7 @@ import org.apache.sysml.runtime.matrix.mapred.IndexedMatrixValue; public class CombineTernaryInstruction extends TernaryInstruction { private CombineTernaryInstruction(OperationTypes op, byte in1, byte in2, byte in3, byte out, String istr) { - super(op, in1, in2, in3, out, -1, -1, istr); - mrtype = MRINSTRUCTION_TYPE.CombineTernary; + super(MRType.CombineTernary, op, in1, in2, in3, out, -1, -1, istr); } public static CombineTernaryInstruction parseInstruction ( String str ) throws DMLRuntimeException { http://git-wip-us.apache.org/repos/asf/systemml/blob/4d1ee8e1/src/main/java/org/apache/sysml/runtime/instructions/mr/CombineUnaryInstruction.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/instructions/mr/CombineUnaryInstruction.java b/src/main/java/org/apache/sysml/runtime/instructions/mr/CombineUnaryInstruction.java index 4c4f4b0..d255148 100644 --- a/src/main/java/org/apache/sysml/runtime/instructions/mr/CombineUnaryInstruction.java +++ b/src/main/java/org/apache/sysml/runtime/instructions/mr/CombineUnaryInstruction.java @@ -28,12 +28,8 @@ import org.apache.sysml.runtime.matrix.operators.Operator; public class CombineUnaryInstruction extends UnaryMRInstructionBase { - /* - * combineunary:::0:DOUBLE:::1:DOUBLE - */ private CombineUnaryInstruction(Operator op, byte in, byte out, String istr) { - super(op, in, out); - mrtype = MRINSTRUCTION_TYPE.CombineUnary; + super(MRType.CombineUnary, op, in, out); instString = istr; } http://git-wip-us.apache.org/repos/asf/systemml/blob/4d1ee8e1/src/main/java/org/apache/sysml/runtime/instructions/mr/CumulativeOffsetInstruction.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/instructions/mr/CumulativeOffsetInstruction.java b/src/main/java/org/apache/sysml/runtime/instructions/mr/CumulativeOffsetInstruction.java index fe3655f..e01be29 100644 --- a/src/main/java/org/apache/sysml/runtime/instructions/mr/CumulativeOffsetInstruction.java +++ b/src/main/java/org/apache/sysml/runtime/instructions/mr/CumulativeOffsetInstruction.java @@ -36,7 +36,7 @@ public class CumulativeOffsetInstruction extends BinaryInstruction { private UnaryOperator _uop = null; private CumulativeOffsetInstruction(byte in1, byte in2, byte out, String opcode, String istr) { - super(null, in1, in2, out, istr); + super(MRType.CumsumOffset, null, in1, in2, out, istr); if ("bcumoffk+".equals(opcode)) { _bop = new BinaryOperator(Plus.getPlusFnObject());
