Examples with FfunctionDefinition claw.tatsu.xcodeml.xnode.fortran.FfunctionDefinition used on opensource projects

Example 1 with FfunctionDefinition

use of claw.tatsu.xcodeml.xnode.fortran.FfunctionDefinition in project claw-compiler by C2SM-RCM.

the class ScaForward method transformStd.

/**
 * Do the standard transformation for the forward directive. This transformation
 * adapt the function call and replicates any necessary changes to the
 * containing subroutine.
 *
 * @param xcodeml    Current XcodeML file unit.
 * @param translator Current translator.
 * @throws Exception If something goes wrong.
 */
private void transformStd(XcodeProgram xcodeml, Translator translator) throws Exception {
    ClawTranslator trans = (ClawTranslator) translator;
    final Context context = trans.context();
    final Configuration cfg = trans.cfg();
    FfunctionDefinition fDef = _claw.getPragma().findParentFunction();
    if (fDef == null) {
        throw new IllegalTransformationException("SCA directive is not " + "nested in a function/subroutine.", _claw.getPragma().lineNo());
    }
    FfunctionType parentFctType = xcodeml.getTypeTable().getFunctionType(fDef);
    if (_fctType.isElemental() || _fctType.getBooleanAttribute(Xattr.WAS_ELEMENTAL)) {
        _flatten = true;
    }
    List<Xnode> params = _fctType.getParameters();
    /*
         * Compute the position of the first new arguments. In the case of a type-bound
         * procedure call, the first parameter declared in the procedure is not actually
         * passed as an argument. In this case, we add an offset of one to the starting
         * arguments. TODO the check might be change to fit with the XcodeML/F2008
         * specs. The TODO cont: attribute data_ref will probably be gone and replaced
         * by a TODO cont: FmemberRef element
         */
    int argOffset = 0;
    if (!params.isEmpty() && FortranType.STRUCT.isOfType(params.get(0).getType()) && _fCall.isTbpCall()) {
        argOffset = 1;
    }
    // 1. Adapt function call with potential new arguments
    for (int i = 0; i < params.size(); i++) {
        Xnode p = params.get(i);
        String varId = p.value();
        String type;
        FbasicType paramType = xcodeml.getTypeTable().getBasicType(p);
        if (!p.getBooleanAttribute(Xattr.IS_INSERTED)) {
            continue;
        }
        if (!fDef.getSymbolTable().contains(varId)) {
            if (_flatten && !paramType.getBooleanAttribute(Xattr.IS_OPTIONAL)) {
                throw new IllegalTransformationException("Variable " + varId + " must be locally defined where the last call to one_column " + "is made.", _claw.getPragma().lineNo());
            }
            // Size variable have to be declared
            FbasicType bt = xcodeml.createBasicType(FortranType.INTEGER, Intent.IN);
            xcodeml.getTypeTable().add(bt);
            xcodeml.createIdAndDecl(varId, bt.getType(), XstorageClass.F_PARAM, fDef, DeclarationPosition.FIRST);
            type = bt.getType();
            Xnode param = xcodeml.createAndAddParam(varId, type, parentFctType);
            param.setBooleanAttribute(Xattr.IS_INSERTED, true);
        } else {
            // Var exists already. Add to the parameters if not here.
            type = fDef.getSymbolTable().get(varId).getType();
            /*
                 * If flatten mode, we do not add extra parameters to the function definition.
                 */
            if (!_flatten && !fDef.getSymbolTable().contains(varId)) {
                Xnode param = xcodeml.createAndAddParamIfNotExists(varId, type, parentFctType);
                if (param != null) {
                    param.setBooleanAttribute(Xattr.IS_INSERTED, true);
                }
            }
        }
        // Add variable in the function call before the optional parameters
        Xnode arg = xcodeml.createNamedValue(varId);
        arg.append(xcodeml.createVar(type, varId, Xscope.LOCAL));
        Xnode hook = _fCall.arguments().get((i - 1) - argOffset);
        if (hook != null) {
            hook.insertAfter(arg);
        } else {
            _fCall.addArguments(arg);
        }
    }
    // In flatten mode, arguments are demoted if needed.
    if (_flatten) {
        for (Xnode arg : _fCall.arguments()) {
            if (arg.is(Xcode.F_ARRAY_REF) && arg.matchDirectDescendant(Arrays.asList(Xcode.INDEX_RANGE, Xcode.ARRAY_INDEX)) != null) {
                List<Xnode> arrayIndexes = arg.matchAll(Xcode.ARRAY_INDEX);
                for (Xnode n : arrayIndexes) {
                    if (_doStatements != null && XnodeUtil.isInductionIndex(n, _doStatements.getInductionVariables())) {
                        n.insertAfter(xcodeml.createEmptyAssumedShaped());
                        XnodeUtil.safeDelete(n);
                    }
                }
            }
        }
    } else {
        // 2. Adapt function/subroutine in which the function call is nested
        for (Xnode pBase : _fctType.getParameters()) {
            String originalParam = pBase.value();
            if (_fctCallMapping.containsKey(originalParam)) {
                originalParam = _fctCallMapping.get(originalParam);
            }
            Xnode pUpdate = null;
            for (Xnode param : parentFctType.getParameters()) {
                if (originalParam.equals(param.value())) {
                    pUpdate = param;
                }
            }
            if (pUpdate == null) {
                // field is not a parameter but maybe out field
                Xnode d = fDef.getDeclarationTable().get(originalParam);
                if (d != null) {
                    pUpdate = d.matchSeq(Xcode.NAME);
                }
            }
            if (pUpdate != null) {
                if (pUpdate.getType() == null || FortranType.isBuiltInType(pUpdate.getType())) {
                    continue;
                }
                FbasicType typeBase = (_localFct) ? xcodeml.getTypeTable().getBasicType(pBase) : _mod.getTypeTable().getBasicType(pBase);
                FbasicType typeToUpdate = xcodeml.getTypeTable().getBasicType(pUpdate);
                int targetDim = typeBase.getDimensions();
                int baseDim = typeToUpdate.getDimensions();
                // Types have different dimensions
                if (typeBase.getDimensions() > typeToUpdate.getDimensions()) {
                    PromotionInfo promotionInfo = new PromotionInfo(originalParam);
                    promotionInfo.readDimensionsFromString(pBase.getAttribute(Xattr.PROMOTION_INFO));
                    FbasicType type = _localFct ? Type.duplicateWithDimension(typeBase, typeToUpdate, xcodeml, xcodeml, promotionInfo.getDimensions()) : Type.duplicateWithDimension(typeBase, typeToUpdate, _mod, xcodeml, promotionInfo.getDimensions());
                    pUpdate.setType(type);
                    Xid id = fDef.getSymbolTable().get(originalParam);
                    if (id != null) {
                        id.setType(type);
                    }
                    Xnode varDecl = fDef.getDeclarationTable().get(originalParam);
                    if (varDecl != null) {
                        varDecl.matchSeq(Xcode.NAME).setType(type);
                    }
                    promotionInfo.setBaseDimension(baseDim);
                    promotionInfo.setTargetDimension(targetDim);
                    promotionInfo.setTargetType(type);
                    _promotions.put(originalParam, promotionInfo);
                    _promotedVar.add(originalParam);
                    pBase.copyAttribute(pUpdate, Xattr.PROMOTION_INFO);
                }
            }
        }
        if (!parentFctType.getBooleanAttribute(Xattr.IS_PRIVATE)) {
            // 3. Replicate the change in a potential module file
            FmoduleDefinition modDef = fDef.findParentModule();
            if (modDef != null) {
                Xmod.updateSignature(modDef.getName(), xcodeml, fDef, parentFctType, false);
            }
        } else if (_fCall.matchSeq(Xcode.NAME).hasAttribute(Xattr.DATA_REF)) {
            /*
                 * The function/subroutine is private but accessible through the type as a
                 * type-bound procedure. In this case, the function is not in the type table of
                 * the .xmod file. We need to insert it first and then we can update it.
                 */
            FmoduleDefinition modDef = fDef.findParentModule();
            if (modDef != null) {
                Xmod.updateSignature(modDef.getName(), xcodeml, fDef, parentFctType, true);
            }
        }
    }
    updateResultVar(xcodeml);
    propagatePromotion(xcodeml, (ClawTranslator) translator);
    Xnode fctCallAncestor = _fCall.matchAncestor(Xcode.EXPR_STATEMENT);
    if (fctCallAncestor == null) {
        fctCallAncestor = _fCall.matchAncestor(Xcode.F_ASSIGN_STATEMENT);
    }
    if (_claw.hasClause(ClawClause.CREATE) && context.isTarget(Target.GPU)) {
        List<String> creates = _fCall.gatherArguments(xcodeml, _fctType, _mod, Intent.INOUT, true, false);
        if (_fctType.isFunction()) {
            String returnValue = XnodeUtil.gatherReturnValue(xcodeml, _fCall);
            if (returnValue != null) {
                creates.add(returnValue);
            }
        }
        Xblock fctCallBlock = new Xblock(fctCallAncestor);
        Directive.generateDataRegionClause(xcodeml, Collections.emptyList(), creates, fctCallBlock);
    }
    // Serialization input
    if (_claw.hasClause(ClawClause.SAVEPOINT)) {
        List<String> inFields = _fCall.gatherArguments(xcodeml, _fctType, _mod != null ? _mod : xcodeml, Intent.IN, true, false);
        Serialization.insertImports(cfg, xcodeml, _fCall.findParentFunction());
        if (context.isTarget(Target.CPU)) {
            Serialization.generateWriteSavepoint(cfg, xcodeml, fctCallAncestor, _claw.getMetadataMap(), inFields, _claw.value(ClawClause.SAVEPOINT), SerializationStep.SER_IN);
        } else {
            Serialization.generateReadSavepoint(cfg, xcodeml, fctCallAncestor, _claw.getMetadataMap(), inFields, _claw.value(ClawClause.SAVEPOINT), SerializationStep.SER_IN);
        }
    }
    Xnode postHook = fctCallAncestor;
    if (_claw.hasClause(ClawClause.UPDATE) && context.isTarget(Target.GPU) && cfg.getBooleanParameter(Configuration.SCA_FORWARD_UPDATE_ENABLED)) {
        // Generate update from HOST TO DEVICE
        if ((_claw.getUpdateClauseValue() == DataMovement.TWO_WAY || _claw.getUpdateClauseValue() == DataMovement.HOST_TO_DEVICE) && cfg.updateAtInput()) {
            List<String> in = _fCall.gatherArguments(xcodeml, _fctType, _mod != null ? _mod : xcodeml, Intent.IN, true, false);
            Directive.generateUpdate(xcodeml, fctCallAncestor, in, DataMovement.HOST_TO_DEVICE);
        }
        // Generate update from DEVICE to HOST
        if ((_claw.getUpdateClauseValue() == DataMovement.TWO_WAY || _claw.getUpdateClauseValue() == DataMovement.DEVICE_TO_HOST) && cfg.updateAtOutput()) {
            List<String> out = _fCall.gatherArguments(xcodeml, _fctType, _mod != null ? _mod : xcodeml, Intent.OUT, true, false);
            if (_fctType.isFunction()) {
                String returnValue = XnodeUtil.gatherReturnValue(xcodeml, _fCall);
                if (returnValue != null) {
                    out.add(returnValue);
                }
            }
            postHook = Directive.generateUpdate(xcodeml, fctCallAncestor, out, DataMovement.DEVICE_TO_HOST);
        }
    }
    if (_claw.hasClause(ClawClause.PARALLEL) && context.isTarget(Target.GPU)) {
        Directive.generateParallelRegion(xcodeml, fctCallAncestor, fctCallAncestor);
    }
    // Serialization output
    if (_claw.hasClause(ClawClause.SAVEPOINT)) {
        List<String> outFields = _fCall.gatherArguments(xcodeml, _fctType, _mod != null ? _mod : xcodeml, Intent.OUT, true, false);
        Serialization.insertImports(cfg, xcodeml, _fCall.findParentFunction());
        Serialization.generateWriteSavepoint(cfg, xcodeml, postHook, _claw.getMetadataMap(), outFields, _claw.value(ClawClause.SAVEPOINT), SerializationStep.SER_OUT);
    }
}

Example 2 with FfunctionDefinition

use of claw.tatsu.xcodeml.xnode.fortran.FfunctionDefinition in project claw-compiler by C2SM-RCM.

the class ScaForward method updateResultVar.

/**
 * Apply promotion to the result return variable of a forward call.
 *
 * @param xcodeml Current XcodeML program unit.
 * @throws IllegalTransformationException If XcodeML transformation cannot be
 *                                        done.
 */
private void updateResultVar(XcodeProgram xcodeml) throws IllegalTransformationException {
    if (_isNestedInAssignment) {
        Xnode assignment = _claw.getPragma().nextSibling();
        if (assignment == null || !_fctType.hasAttribute(Xattr.PROMOTION_INFO)) {
            return;
        }
        Xnode lhs = assignment.firstChild();
        // TODO handle the case when the array ref is a var directly
        Xnode varInLhs = lhs.matchDescendant(Xcode.VAR);
        FfunctionDefinition parentFctDef = _fCall.findParentFunction();
        PromotionInfo promotionInfo;
        if (!_promotions.containsKey(varInLhs.value())) {
            // Perform the promotion on the variable
            promotionInfo = new PromotionInfo(varInLhs.value());
            promotionInfo.readDimensionsFromString(_fctType.getAttribute(Xattr.PROMOTION_INFO));
            Field.promote(promotionInfo, parentFctDef, xcodeml);
            _promotions.put(varInLhs.value(), promotionInfo);
            _promotedVar.add(varInLhs.value());
        } else {
            promotionInfo = _promotions.get(varInLhs.value());
        }
        // Adapt array index to reflect the new return type
        if (Xnode.isOfCode(lhs, Xcode.F_ARRAY_REF)) {
            for (int i = 0; i < promotionInfo.diffDimension(); ++i) {
                Xnode indexRange = xcodeml.createEmptyAssumedShaped();
                lhs.append(indexRange);
            }
        } else {
            throw new IllegalTransformationException("Unsupported return " + "variable for promotion.", _claw.getPragma().lineNo());
        }
        // If the array is a target, check if we have to promote a pointer
        Field.adaptPointer(xcodeml, parentFctDef, _promotions, promotionInfo);
    }
}

Example 3 with FfunctionDefinition

use of claw.tatsu.xcodeml.xnode.fortran.FfunctionDefinition in project claw-compiler by C2SM-RCM.

the class LoopExtraction method analyze.

/**
 * Check whether the transformation can be applied.
 *
 * @param xcodeml    The XcodeML on which the transformations are applied.
 * @param translator The translator used to applied the transformations.
 * @return True if the transformation analysis succeeded. False otherwise.
 */
@Override
public boolean analyze(XcodeProgram xcodeml, Translator translator) {
    Xnode _exprStmt = _claw.getPragma().matchSibling(Xcode.EXPR_STATEMENT);
    if (_exprStmt == null) {
        xcodeml.addError("No function call detected after loop-extract", _claw.getPragma().lineNo());
        return false;
    }
    // Find function CALL
    Xnode fctCallNode = _exprStmt.matchDescendant(Xcode.FUNCTION_CALL);
    if (fctCallNode == null) {
        xcodeml.addError("No function call detected after loop-extract", _claw.getPragma().lineNo());
        return false;
    }
    _fctCall = new FunctionCall(fctCallNode);
    Xnode fctDef = _fctCall.matchAncestor(Xcode.F_FUNCTION_DEFINITION);
    if (fctDef == null) {
        xcodeml.addError("No function around the fct call", _claw.getPragma().lineNo());
        return false;
    }
    _fctDef = new FfunctionDefinition(fctDef);
    // Find function declaration
    String fctName = _fctCall.matchDirectDescendant(Xcode.NAME).value();
    _fctDefToExtract = xcodeml.getGlobalDeclarationsTable().getFunctionDefinition(fctName);
    if (_fctDefToExtract == null) {
        xcodeml.addError("Could not locate the function definition for: " + _fctCall.matchDirectDescendant(Xcode.NAME).value(), _claw.getPragma().lineNo());
        return false;
    }
    // Find the loop to be extracted
    try {
        _extractedLoop = locateDoStatement(_fctDefToExtract);
    } catch (IllegalTransformationException itex) {
        xcodeml.addError(itex.getMessage(), _claw.getPragma().lineNo());
        return false;
    }
    return checkMappingInformation(xcodeml);
}

Example 4 with FfunctionDefinition

use of claw.tatsu.xcodeml.xnode.fortran.FfunctionDefinition in project claw-compiler by C2SM-RCM.

the class LoopHoist method analyze.

/**
 * @see Transformation#analyze(XcodeProgram, Translator)
 */
@Override
public boolean analyze(XcodeProgram xcodeml, Translator translator) {
    if (_clawEnd == null) {
        xcodeml.addError("loop-hoist directive requires an end directive.", _clawStart.getPragma().lineNo());
        return false;
    }
    int pragmaDepthLevel = _clawStart.getPragma().depth();
    // Find all the group of nested loops that can be part of the hoisting
    List<HoistedNestedDoStatement> statements = XnodeUtil.findDoStatementForHoisting(_clawStart.getPragma(), _clawEnd.getPragma(), _clawStart.values(ClawClause.HOIST_INDUCTIONS));
    if (statements.isEmpty()) {
        xcodeml.addError("No do statement group meets the criteria of hoisting.", _clawStart.getPragma().lineNo());
        return false;
    }
    for (HoistedNestedDoStatement hoistedNestedDoStmt : statements) {
        int depth = hoistedNestedDoStmt.getOuterStatement().depth();
        if (depth != pragmaDepthLevel) {
            Xnode tmpIf = hoistedNestedDoStmt.getOuterStatement().matchAncestor(Xcode.F_IF_STATEMENT);
            Xnode tmpSelect = hoistedNestedDoStmt.getOuterStatement().matchAncestor(Xcode.F_SELECT_CASE_STATEMENT);
            Xnode tmpDo = hoistedNestedDoStmt.getOuterStatement().matchAncestor(Xcode.F_DO_STATEMENT);
            if (tmpIf == null && tmpSelect == null && tmpDo == null) {
                xcodeml.addError("A nested do stmt group is nested in an unsupported " + "statement for loop hoisting.", hoistedNestedDoStmt.getOuterStatement().lineNo());
                return false;
            }
            int ifDepth = (tmpIf != null) ? tmpIf.depth() : Xnode.UNDEF_DEPTH;
            int selectDepth = (tmpSelect != null) ? tmpSelect.depth() : Xnode.UNDEF_DEPTH;
            int doDepth = (tmpDo != null) ? tmpDo.depth() : Xnode.UNDEF_DEPTH;
            if ((pragmaDepthLevel <= ifDepth || pragmaDepthLevel <= selectDepth || pragmaDepthLevel <= doDepth) && (ifDepth < depth || selectDepth < depth || doDepth < depth)) {
                hoistedNestedDoStmt.setExtraction();
            } else {
                xcodeml.addError("Group is nested in an unsupported " + "statement for loop hoisting or depth is too high " + "(Group index starts at 0).", _clawStart.getPragma().lineNo());
                return false;
            }
        }
        _hoistedGroups.add(hoistedNestedDoStmt);
    }
    HoistedNestedDoStatement master = _hoistedGroups.get(0);
    for (int i = 1; i < _hoistedGroups.size(); ++i) {
        HoistedNestedDoStatement next = _hoistedGroups.get(i);
        for (int j = 0; j < master.size(); ++j) {
            // Iteration range are identical, just merge
            if (j == 0 && (!Loop.hasSameIndexRange(master.get(j), next.get(j)) && Loop.hasSameIndexRangeBesidesLower(master.get(j), next.get(j)))) {
                // Iteration range are identical besides lower-bound, if creation
                next.setIfStatement();
            } else if (!Loop.hasSameIndexRange(master.get(j), next.get(j))) {
                // Iteration range are too different, stop analysis
                xcodeml.addError("Iteration range of do statements group " + i + " differs from group 0. Loop hoisting aborted.", _clawStart.getPragma().lineNo());
                return false;
            }
        }
    }
    // Check reshape mandatory points
    if (_clawStart.hasClause(ClawClause.RESHAPE)) {
        FfunctionDefinition fctDef = _clawStart.getPragma().findParentFunction();
        if (fctDef == null) {
            xcodeml.addError("Unable to matchSeq the function/subroutine/module " + "definition including the current directive", _clawStart.getPragma().lineNo());
            return false;
        }
        for (ReshapeInfo r : _clawStart.getReshapeClauseValues()) {
            if (!fctDef.getSymbolTable().contains(r.getArrayName()) || !fctDef.getDeclarationTable().contains(r.getArrayName())) {
                // Check in the parent def if present
                if (!checkUpperDefinition(fctDef, r.getArrayName())) {
                    xcodeml.addError(String.format("Reshape variable %s not found in " + "the definition of %s", r.getArrayName(), fctDef.getName()), _clawStart.getPragma().lineNo());
                    return false;
                }
            }
        }
    }
    return true;
}

Example 5 with FfunctionDefinition

use of claw.tatsu.xcodeml.xnode.fortran.FfunctionDefinition in project claw-compiler by C2SM-RCM.

the class ExpandNotation method transform.

/**
 * Transform an assignment using array notation to a do statement.
 *
 * @param xcodeml    The XcodeML on which the transformations are applied.
 * @param translator The translator used to applied the transformations.
 * @param other      Only for dependent transformation. The other transformation
 *                   part of the transformation.
 * @throws Exception If the transformation cannot be applied.
 */
@Override
public void transform(XcodeProgram xcodeml, Translator translator, Transformation other) throws Exception {
    final ClawTranslator ct = (ClawTranslator) translator;
    final Configuration cfg = ct.cfg();
    // 1. Find the function/module declaration TODO handle module/program ?
    FfunctionDefinition fctDef = _clawStart.getPragma().findParentFunction();
    Xnode from = _clawStart.getPragma();
    Xnode to = _clawEnd != null ? _clawEnd.getPragma() : null;
    List<String> readArrays = XnodeUtil.getReadArraysInRegion(from, to);
    List<String> writtenArrays = XnodeUtil.getWrittenArraysInRegion(from, to);
    Set<String> presents = new HashSet<>(readArrays);
    presents.addAll(writtenArrays);
    Xblock doStmtsBlock = null;
    Xblock dataRegionBlock = null;
    if (xcodeml.context().isTarget(Target.GPU)) {
        Xblock crtBlock;
        for (int i = 0; i < _groupedAssignStmts.size(); ++i) {
            crtBlock = generateDoStmtNotation(xcodeml, ct, fctDef, _groupIterationRanges.get(i), _groupedAssignStmts.get(i), from);
            if (doStmtsBlock == null) {
                doStmtsBlock = new Xblock(crtBlock.getStart());
            } else {
                doStmtsBlock.setEnd(crtBlock.getEnd());
            }
        }
        if (doStmtsBlock == null) {
            throw new IllegalTransformationException("Problem occurred during expand transformation", _clawStart.getPragma().lineNo());
        }
        Xblock parallelRegionBlock;
        Xblock updateRegionBlock = null;
        if (_clawStart.hasClause(ClawClause.PARALLEL)) {
            List<String> privates = Collections.emptyList();
            String clauses = _clawStart.hasClause(ClawClause.ACC) ? _clawStart.value(ClawClause.ACC) : "";
            parallelRegionBlock = Directive.generateParallelLoopClause(xcodeml, privates, doStmtsBlock.getStart(), doStmtsBlock.getEnd(), clauses, _groupedAssignStmts.size());
            if (_clawStart.hasClause(ClawClause.UPDATE) && cfg.getBooleanParameter(Configuration.SCA_FORWARD_UPDATE_ENABLED)) {
                updateRegionBlock = generateUpdateClause(cfg, xcodeml, parallelRegionBlock, readArrays, writtenArrays);
            }
            if (updateRegionBlock == null) {
                updateRegionBlock = parallelRegionBlock;
            }
            List<String> presentLst = new ArrayList<>(presents);
            dataRegionBlock = Directive.generateDataRegionClause(xcodeml, presentLst, Collections.emptyList(), updateRegionBlock);
        }
    } else {
        doStmtsBlock = new Xblock(_clawStart.getPragma());
        if (_clawEnd != null) {
            doStmtsBlock.setEnd(_clawEnd.getPragma());
        } else {
            doStmtsBlock.setEnd(_clawStart.getPragma().nextSibling());
        }
    }
    if (_clawStart.hasClause(ClawClause.SAVEPOINT) && cfg.getBooleanParameter(Configuration.SCA_SERIALIZATION_ENABLED)) {
        if (dataRegionBlock == null) {
            dataRegionBlock = doStmtsBlock;
        }
        generateSavepoint(cfg, xcodeml, dataRegionBlock, readArrays, writtenArrays);
    }
    removePragma();
    transformed();
}