| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package org.apache.sysml.runtime.instructions; |
| |
| import java.util.HashMap; |
| |
| import org.apache.sysml.lops.BinaryM; |
| import org.apache.sysml.lops.DataGen; |
| import org.apache.sysml.lops.MapMult; |
| import org.apache.sysml.lops.MapMultChain; |
| import org.apache.sysml.lops.WeightedCrossEntropy; |
| import org.apache.sysml.lops.WeightedCrossEntropyR; |
| import org.apache.sysml.lops.WeightedDivMM; |
| import org.apache.sysml.lops.WeightedDivMMR; |
| import org.apache.sysml.lops.WeightedSigmoid; |
| import org.apache.sysml.lops.WeightedSigmoidR; |
| import org.apache.sysml.lops.WeightedSquaredLoss; |
| import org.apache.sysml.lops.WeightedSquaredLossR; |
| import org.apache.sysml.lops.WeightedUnaryMM; |
| import org.apache.sysml.lops.WeightedUnaryMMR; |
| import org.apache.sysml.runtime.DMLRuntimeException; |
| import org.apache.sysml.runtime.instructions.mr.AggregateBinaryInstruction; |
| import org.apache.sysml.runtime.instructions.mr.AggregateInstruction; |
| import org.apache.sysml.runtime.instructions.mr.AggregateUnaryInstruction; |
| import org.apache.sysml.runtime.instructions.mr.AppendInstruction; |
| import org.apache.sysml.runtime.instructions.mr.BinUaggChainInstruction; |
| import org.apache.sysml.runtime.instructions.mr.BinaryInstruction; |
| import org.apache.sysml.runtime.instructions.mr.BinaryMInstruction; |
| import org.apache.sysml.runtime.instructions.mr.CM_N_COVInstruction; |
| import org.apache.sysml.runtime.instructions.mr.CSVReblockInstruction; |
| import org.apache.sysml.runtime.instructions.mr.CSVWriteInstruction; |
| import org.apache.sysml.runtime.instructions.mr.CombineBinaryInstruction; |
| import org.apache.sysml.runtime.instructions.mr.CombineTernaryInstruction; |
| import org.apache.sysml.runtime.instructions.mr.CombineUnaryInstruction; |
| import org.apache.sysml.runtime.instructions.mr.CumulativeAggregateInstruction; |
| import org.apache.sysml.runtime.instructions.mr.CumulativeOffsetInstruction; |
| import org.apache.sysml.runtime.instructions.mr.CumulativeSplitInstruction; |
| import org.apache.sysml.runtime.instructions.mr.DataGenMRInstruction; |
| import org.apache.sysml.runtime.instructions.mr.DataPartitionMRInstruction; |
| import org.apache.sysml.runtime.instructions.mr.GroupedAggregateInstruction; |
| import org.apache.sysml.runtime.instructions.mr.GroupedAggregateMInstruction; |
| import org.apache.sysml.runtime.instructions.mr.MMTSJMRInstruction; |
| import org.apache.sysml.runtime.instructions.mr.MRInstruction; |
| import org.apache.sysml.runtime.instructions.mr.MapMultChainInstruction; |
| import org.apache.sysml.runtime.instructions.mr.MatrixReshapeMRInstruction; |
| import org.apache.sysml.runtime.instructions.mr.PMMJMRInstruction; |
| import org.apache.sysml.runtime.instructions.mr.ParameterizedBuiltinMRInstruction; |
| import org.apache.sysml.runtime.instructions.mr.PickByCountInstruction; |
| import org.apache.sysml.runtime.instructions.mr.PlusMultInstruction; |
| import org.apache.sysml.runtime.instructions.mr.QuaternaryInstruction; |
| import org.apache.sysml.runtime.instructions.mr.RandInstruction; |
| import org.apache.sysml.runtime.instructions.mr.RangeBasedReIndexInstruction; |
| import org.apache.sysml.runtime.instructions.mr.ReblockInstruction; |
| import org.apache.sysml.runtime.instructions.mr.RemoveEmptyMRInstruction; |
| import org.apache.sysml.runtime.instructions.mr.ReorgInstruction; |
| import org.apache.sysml.runtime.instructions.mr.ReplicateInstruction; |
| import org.apache.sysml.runtime.instructions.mr.ScalarInstruction; |
| import org.apache.sysml.runtime.instructions.mr.SeqInstruction; |
| 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.matrix.SortMR; |
| |
| |
| public class MRInstructionParser extends InstructionParser |
| { |
| static public HashMap<String, MRINSTRUCTION_TYPE> String2MRInstructionType; |
| static { |
| String2MRInstructionType = new HashMap<String, MRINSTRUCTION_TYPE>(); |
| |
| // 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); |
| |
| // AGG_BINARY Instruction Opcodes |
| String2MRInstructionType.put( "cpmm" , MRINSTRUCTION_TYPE.AggregateBinary); |
| String2MRInstructionType.put( "rmm" , MRINSTRUCTION_TYPE.AggregateBinary); |
| String2MRInstructionType.put( MapMult.OPCODE, MRINSTRUCTION_TYPE.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); |
| |
| // 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); |
| |
| // 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); |
| |
| // 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.ArithmeticBinary2); |
| String2MRInstructionType.put( "-*" , MRINSTRUCTION_TYPE.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( "uaggouterchain", MRINSTRUCTION_TYPE.UaggOuterChain); |
| |
| // REORG Instruction Opcodes |
| String2MRInstructionType.put( "r'" , MRINSTRUCTION_TYPE.Reorg); |
| String2MRInstructionType.put( "rev" , MRINSTRUCTION_TYPE.Reorg); |
| String2MRInstructionType.put( "rdiag" , MRINSTRUCTION_TYPE.Reorg); |
| |
| // REPLICATE Instruction Opcodes |
| String2MRInstructionType.put( "rep" , MRINSTRUCTION_TYPE.Replicate); |
| |
| // DataGen Instruction Opcodes |
| String2MRInstructionType.put( DataGen.RAND_OPCODE , MRINSTRUCTION_TYPE.Rand); |
| String2MRInstructionType.put( DataGen.SEQ_OPCODE , MRINSTRUCTION_TYPE.Seq); |
| |
| // REBLOCK Instruction Opcodes |
| String2MRInstructionType.put( "rblk" , MRINSTRUCTION_TYPE.Reblock); |
| String2MRInstructionType.put( "csvrblk", MRINSTRUCTION_TYPE.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); |
| |
| // 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); |
| |
| // Combine Instruction Opcodes |
| String2MRInstructionType.put( "combinebinary" , MRINSTRUCTION_TYPE.CombineBinary); |
| String2MRInstructionType.put( "combineunary" , MRINSTRUCTION_TYPE.CombineUnary); |
| String2MRInstructionType.put( "combineternary" , MRINSTRUCTION_TYPE.CombineTernary); |
| |
| // PickByCount Instruction Opcodes |
| String2MRInstructionType.put( "valuepick" , MRINSTRUCTION_TYPE.PickByCount); // for quantile() |
| String2MRInstructionType.put( "rangepick" , MRINSTRUCTION_TYPE.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); |
| |
| //groupedAgg Instruction Opcodes |
| String2MRInstructionType.put( "groupedagg" , MRINSTRUCTION_TYPE.GroupedAggregate); |
| String2MRInstructionType.put( "mapgroupedagg" , MRINSTRUCTION_TYPE.MapGroupedAggregate); |
| |
| //rangereindexing |
| String2MRInstructionType.put( "rangeReIndex" , MRINSTRUCTION_TYPE.RangeReIndex); |
| String2MRInstructionType.put( "rangeReIndexForLeft" , MRINSTRUCTION_TYPE.RangeReIndex); |
| String2MRInstructionType.put( "zeroOut" , MRINSTRUCTION_TYPE.ZeroOut); |
| |
| //append |
| String2MRInstructionType.put( "mappend" , MRINSTRUCTION_TYPE.Append); |
| String2MRInstructionType.put( "rappend" , MRINSTRUCTION_TYPE.Append); |
| String2MRInstructionType.put( "gappend" , MRINSTRUCTION_TYPE.Append); |
| |
| //misc |
| String2MRInstructionType.put( "rshape", MRINSTRUCTION_TYPE.MatrixReshape); |
| |
| //partitioning |
| String2MRInstructionType.put( "partition", MRINSTRUCTION_TYPE.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); |
| |
| //dummy (pseudo instructions) |
| String2MRInstructionType.put( "sort", MRINSTRUCTION_TYPE.Sort); |
| String2MRInstructionType.put( "csvwrite", MRINSTRUCTION_TYPE.CSVWrite); |
| String2MRInstructionType.put( "transform", MRINSTRUCTION_TYPE.Transform); |
| |
| //parameterized builtins |
| String2MRInstructionType.put( "replace", MRINSTRUCTION_TYPE.ParameterizedBuiltin); |
| String2MRInstructionType.put( "rexpand", MRINSTRUCTION_TYPE.ParameterizedBuiltin); |
| |
| //remove empty (special type since binary not unary) |
| String2MRInstructionType.put( "rmempty", MRINSTRUCTION_TYPE.RemoveEmpty); |
| } |
| |
| |
| public static MRInstruction parseSingleInstruction (String str ) |
| throws DMLRuntimeException |
| { |
| if ( str == null || str.isEmpty() ) |
| return null; |
| |
| MRINSTRUCTION_TYPE mrtype = InstructionUtils.getMRType(str); |
| return parseSingleInstruction(mrtype, str); |
| } |
| |
| public static MRInstruction parseSingleInstruction (MRINSTRUCTION_TYPE mrtype, String str ) |
| throws DMLRuntimeException |
| { |
| if ( str == null || str.isEmpty() ) |
| return null; |
| |
| switch(mrtype) |
| { |
| case Aggregate: |
| return AggregateInstruction.parseInstruction(str); |
| |
| case ArithmeticBinary: { |
| String opcode = InstructionUtils.getOpCode(str); |
| String[] parts = InstructionUtils.getInstructionPartsWithValueType(str); |
| // extract datatypes of first and second input operands |
| String dt1 = parts[1].split(Instruction.DATATYPE_PREFIX)[1].split(Instruction.VALUETYPE_PREFIX)[0]; |
| String dt2 = parts[2].split(Instruction.DATATYPE_PREFIX)[1].split(Instruction.VALUETYPE_PREFIX)[0]; |
| if ( dt1.equalsIgnoreCase("SCALAR") || dt2.equalsIgnoreCase("SCALAR") ) { |
| return ScalarInstruction.parseInstruction(str); |
| } |
| else { |
| if( BinaryM.isOpcode( opcode ) ) |
| return BinaryMInstruction.parseInstruction(str); |
| else |
| return BinaryInstruction.parseInstruction(str); |
| } |
| } |
| |
| case ArithmeticBinary2: |
| return PlusMultInstruction.parseInstruction(str); |
| |
| case AggregateBinary: |
| return AggregateBinaryInstruction.parseInstruction(str); |
| |
| case AggregateUnary: |
| return AggregateUnaryInstruction.parseInstruction(str); |
| |
| case Ternary: |
| return TernaryInstruction.parseInstruction(str); |
| |
| case Quaternary: |
| return QuaternaryInstruction.parseInstruction(str); |
| |
| case Rand: |
| return RandInstruction.parseInstruction(str); |
| |
| case Seq: |
| return SeqInstruction.parseInstruction(str); |
| |
| case Reblock: |
| return ReblockInstruction.parseInstruction(str); |
| |
| case Append: |
| return AppendInstruction.parseInstruction(str); |
| |
| case Reorg: |
| return ReorgInstruction.parseInstruction(str); |
| |
| case Replicate: |
| return ReplicateInstruction.parseInstruction(str); |
| |
| case Unary: { |
| String opcode = InstructionUtils.getOpCode(str); |
| String[] parts = InstructionUtils.getInstructionPartsWithValueType(str); |
| if( parts.length==4 && (opcode.equalsIgnoreCase("log") || opcode.equalsIgnoreCase("log_nz")) ) |
| return ScalarInstruction.parseInstruction(str); |
| else //default case |
| return UnaryInstruction.parseInstruction(str); |
| } |
| case MMTSJ: |
| return MMTSJMRInstruction.parseInstruction(str); |
| |
| case PMMJ: |
| return PMMJMRInstruction.parseInstruction(str); |
| |
| case MapMultChain: |
| return MapMultChainInstruction.parseInstruction(str); |
| |
| case BinUaggChain: |
| return BinUaggChainInstruction.parseInstruction(str); |
| |
| case UaggOuterChain: |
| return UaggOuterChainInstruction.parseInstruction(str); |
| |
| case CombineTernary: |
| return CombineTernaryInstruction.parseInstruction(str); |
| |
| case CombineBinary: |
| return CombineBinaryInstruction.parseInstruction(str); |
| |
| case CombineUnary: |
| return CombineUnaryInstruction.parseInstruction(str); |
| |
| case PickByCount: |
| return PickByCountInstruction.parseInstruction(str); |
| |
| case CM_N_COV: |
| return CM_N_COVInstruction.parseInstruction(str); |
| |
| case GroupedAggregate: |
| return GroupedAggregateInstruction.parseInstruction(str); |
| |
| case MapGroupedAggregate: |
| return GroupedAggregateMInstruction.parseInstruction(str); |
| |
| case RangeReIndex: |
| return RangeBasedReIndexInstruction.parseInstruction(str); |
| |
| case ZeroOut: |
| return ZeroOutInstruction.parseInstruction(str); |
| |
| case MatrixReshape: |
| return MatrixReshapeMRInstruction.parseInstruction(str); |
| |
| case Sort: //workaround for dummy MR sort instruction |
| return SortMR.parseSortInstruction(str); |
| |
| case CSVReblock: |
| return CSVReblockInstruction.parseInstruction(str); |
| |
| case CSVWrite: |
| return CSVWriteInstruction.parseInstruction(str); |
| |
| case ParameterizedBuiltin: |
| return ParameterizedBuiltinMRInstruction.parseInstruction(str); |
| |
| case RemoveEmpty: |
| return RemoveEmptyMRInstruction.parseInstruction(str); |
| |
| case Partition: |
| return DataPartitionMRInstruction.parseInstruction(str); |
| |
| case CumsumAggregate: |
| return CumulativeAggregateInstruction.parseInstruction(str); |
| |
| case CumsumSplit: |
| return CumulativeSplitInstruction.parseInstruction(str); |
| |
| case CumsumOffset: |
| return CumulativeOffsetInstruction.parseInstruction(str); |
| |
| case INVALID: |
| |
| default: |
| throw new DMLRuntimeException("Invalid MR Instruction Type: " + mrtype ); |
| } |
| } |
| |
| public static MRInstruction[] parseMixedInstructions ( String str ) throws DMLRuntimeException { |
| if ( str == null || str.isEmpty() ) |
| return null; |
| |
| Instruction[] inst = InstructionParser.parseMixedInstructions(str); |
| MRInstruction[] mrinst = new MRInstruction[inst.length]; |
| for ( int i=0; i < inst.length; i++ ) { |
| mrinst[i] = (MRInstruction) inst[i]; |
| } |
| |
| return mrinst; |
| } |
| |
| public static AggregateInstruction[] parseAggregateInstructions(String str) throws DMLRuntimeException |
| { |
| AggregateInstruction[] inst=null; |
| if(str!=null && !str.isEmpty()) |
| { |
| String[] strlist = str.split(Instruction.INSTRUCTION_DELIM); |
| inst = new AggregateInstruction[strlist.length]; |
| |
| for(int i=0; i < strlist.length; i++) |
| { |
| inst[i] = (AggregateInstruction) AggregateInstruction.parseInstruction( strlist[i] ); |
| } |
| } |
| return inst; |
| } |
| |
| public static ReblockInstruction[] parseReblockInstructions(String str) throws DMLRuntimeException |
| { |
| ReblockInstruction[] inst=null; |
| if(str!=null && !str.isEmpty()) |
| { |
| String[] strlist = str.split(Instruction.INSTRUCTION_DELIM); |
| inst = new ReblockInstruction[strlist.length]; |
| |
| for(int i=0; i < strlist.length; i++) |
| { |
| inst[i] = (ReblockInstruction) ReblockInstruction.parseInstruction( strlist[i] ); |
| } |
| } |
| return inst; |
| } |
| |
| public static CSVReblockInstruction[] parseCSVReblockInstructions(String str) throws DMLRuntimeException |
| { |
| CSVReblockInstruction[] inst=null; |
| if(str!=null && !str.isEmpty()) |
| { |
| String[] strlist = str.split(Instruction.INSTRUCTION_DELIM); |
| inst = new CSVReblockInstruction[strlist.length]; |
| |
| for(int i=0; i < strlist.length; i++) |
| { |
| inst[i] = (CSVReblockInstruction) CSVReblockInstruction.parseInstruction( strlist[i] ); |
| } |
| } |
| return inst; |
| } |
| |
| public static CSVWriteInstruction[] parseCSVWriteInstructions(String str) throws DMLRuntimeException |
| { |
| CSVWriteInstruction[] inst=null; |
| if(str!=null && !str.isEmpty()) |
| { |
| String[] strlist = str.split(Instruction.INSTRUCTION_DELIM); |
| inst = new CSVWriteInstruction[strlist.length]; |
| |
| for(int i=0; i < strlist.length; i++) |
| { |
| inst[i] = (CSVWriteInstruction) CSVWriteInstruction.parseInstruction( strlist[i] ); |
| } |
| } |
| return inst; |
| } |
| |
| public static AggregateBinaryInstruction[] parseAggregateBinaryInstructions(String str) throws DMLRuntimeException |
| { |
| AggregateBinaryInstruction[] inst=null; |
| if(str!=null && !str.isEmpty()) |
| { |
| String[] strlist = str.split(Instruction.INSTRUCTION_DELIM); |
| inst = new AggregateBinaryInstruction[strlist.length]; |
| |
| for(int i=0; i < strlist.length; i++) |
| { |
| inst[i] = (AggregateBinaryInstruction) AggregateBinaryInstruction.parseInstruction( strlist[i] ); |
| } |
| } |
| return inst; |
| } |
| |
| public static DataGenMRInstruction[] parseDataGenInstructions(String str) throws DMLRuntimeException |
| { |
| DataGenMRInstruction[] inst=null; |
| if(str!=null && !str.isEmpty()) |
| { |
| String[] strlist = str.split(Instruction.INSTRUCTION_DELIM); |
| inst = new DataGenMRInstruction[strlist.length]; |
| |
| for(int i=0; i < strlist.length; i++) |
| { |
| inst[i] = (DataGenMRInstruction) InstructionParser.parseSingleInstruction(strlist[i]); |
| } |
| } |
| return inst; |
| } |
| |
| public static MRInstruction[] parseCombineInstructions(String str) throws DMLRuntimeException |
| { |
| MRInstruction[] inst=null; |
| if(str!=null && !str.isEmpty()) |
| { |
| String[] strlist = str.split(Instruction.INSTRUCTION_DELIM); |
| inst = new MRInstruction[strlist.length]; |
| |
| for(int i=0; i < strlist.length; i++) |
| { |
| MRINSTRUCTION_TYPE type = InstructionUtils.getMRType(strlist[i]); |
| if(type==MRINSTRUCTION_TYPE.CombineBinary) |
| inst[i] = (CombineBinaryInstruction) CombineBinaryInstruction.parseInstruction( strlist[i] ); |
| else if(type==MRINSTRUCTION_TYPE.CombineTernary) |
| inst[i] = (CombineTernaryInstruction)CombineTernaryInstruction.parseInstruction(strlist[i]); |
| else |
| throw new DMLRuntimeException("unknown combine instruction: "+strlist[i]); |
| } |
| } |
| return inst; |
| } |
| |
| public static CM_N_COVInstruction[] parseCM_N_COVInstructions(String str) throws DMLRuntimeException |
| { |
| CM_N_COVInstruction[] inst=null; |
| if(str!=null && !str.isEmpty()) |
| { |
| String[] strlist = str.split(Instruction.INSTRUCTION_DELIM); |
| inst = new CM_N_COVInstruction[strlist.length]; |
| |
| for(int i=0; i < strlist.length; i++) |
| { |
| inst[i] = (CM_N_COVInstruction) CM_N_COVInstruction.parseInstruction( strlist[i] ); |
| } |
| } |
| return inst; |
| } |
| |
| public static GroupedAggregateInstruction[] parseGroupedAggInstructions(String str) |
| throws DMLRuntimeException{ |
| GroupedAggregateInstruction[] inst=null; |
| if(str!=null && !str.isEmpty()) |
| { |
| String[] strlist = str.split(Instruction.INSTRUCTION_DELIM); |
| inst = new GroupedAggregateInstruction[strlist.length]; |
| |
| for(int i=0; i < strlist.length; i++) |
| { |
| inst[i] = (GroupedAggregateInstruction) GroupedAggregateInstruction.parseInstruction( strlist[i] ); |
| } |
| } |
| return inst; |
| } |
| } |
