Examples with Xnode claw.tatsu.xcodeml.xnode.common.Xnode used on opensource projects

Example 61 with Xnode

use of claw.tatsu.xcodeml.xnode.common.Xnode in project claw-compiler by C2SM-RCM.

the class Serialization method createSavepoint.

/**
 * Create function call to fs_create_savepoint
 *
 * @param xcodeml       Current XcodeML translation unit.
 * @param savepointName Name of the savepoint.
 * @return Newly create functionCall node.
 */
private static Xnode createSavepoint(XcodeProgram xcodeml, String savepointName) {
    FfunctionType serType = xcodeml.createSubroutineType();
    // Create the char constant type
    Xnode nameArg = xcodeml.createCharConstant(savepointName);
    Xnode savepointArg = xcodeml.createVar(FortranType.STRUCT, SER_PPSER_SAVEPOINT, Xscope.GLOBAL);
    Xnode serCall = xcodeml.createFctCall(serType, SER_FS_CREATE_SAVEPOINT);
    serCall.matchDescendant(Xcode.ARGUMENTS).append(nameArg).append(savepointArg);
    return xcodeml.createNode(Xcode.EXPR_STATEMENT).insert(serCall);
}

Example 62 with Xnode

use of claw.tatsu.xcodeml.xnode.common.Xnode in project claw-compiler by C2SM-RCM.

the class Serialization method insertNodes.

/**
 * Insert nodes for an input or output serialization.
 *
 * @param step  Serialization step information.
 * @param hook  Hook node to start insertion.
 * @param nodes List of nodes to be inserted.
 */
private static Xnode insertNodes(SerializationStep step, Xnode hook, List<Xnode> nodes) {
    Xnode crtHook = hook;
    for (Xnode node : nodes) {
        if (step == SerializationStep.SER_OUT) {
            crtHook.insertAfter(node);
            crtHook = node;
        } else if (step == SerializationStep.SER_IN) {
            if (crtHook.equals(hook)) {
                crtHook.insertBefore(node);
            } else {
                crtHook.insertAfter(node);
            }
            crtHook = node;
        }
    }
    return crtHook;
}

Example 63 with Xnode

use of claw.tatsu.xcodeml.xnode.common.Xnode in project claw-compiler by C2SM-RCM.

the class Serialization method createReadWriteFctCall.

/**
 * @param xcodeml       Current XcodeML translation unit.
 * @param savepointName Name of the savepoint (will be part of the serialized
 *                      name)
 * @param field         Representation of the field.
 * @param callType      Type of serialization call from the enum.
 * @return exprStmt node created with the specific function call inside.
 */
private static Xnode createReadWriteFctCall(XcodeProgram xcodeml, String savepointName, String field, String fieldName, SerializationCall callType) {
    // Create the char constant type
    Xnode nameArg = xcodeml.createCharConstant(savepointName + "_" + fieldName);
    Xnode varArg = xcodeml.createVar(FortranType.REAL, field, Xscope.GLOBAL);
    FunctionCall serCall = createBaseSerFctCall(xcodeml, callType);
    serCall.addArguments(nameArg);
    serCall.addArguments(varArg);
    if (callType == SerializationCall.SER_READ_PERTURB) {
        Xnode perturbArg = xcodeml.createVar(FortranType.REAL, SER_PPSER_ZPERTURB, Xscope.GLOBAL);
        serCall.addArguments(perturbArg);
    }
    Xnode exprStmt = xcodeml.createNode(Xcode.EXPR_STATEMENT);
    exprStmt.insert(serCall);
    return exprStmt;
}

Example 64 with Xnode

use of claw.tatsu.xcodeml.xnode.common.Xnode in project claw-compiler by C2SM-RCM.

the class ExpandNotation method generateDoStmtNotation.

/**
 * Generate the corresponding do statements for the array notations. A do
 * statement is generated per dimension of the arrays. Iteration index range are
 * computed with array dimensions.
 *
 * @param xcodeml    The XcodeML on which the transformations are applied.
 * @param translator The translator used to applied the transformations.
 * @param fctDef     The function definition in which the array notation is
 *                   nested.
 * @param ranges     The list of iteration ranges to be applied to the created
 *                   do statements.
 * @param statements The list of assign statements (array notation) that will be
 *                   included in the nested do statements.
 * @param doStmtGrip Grip for the code insertion. Do statements will be inserted
 *                   after the grip element.
 * @return Block surrounding the do statements generated.
 */
private Xblock generateDoStmtNotation(XcodeProgram xcodeml, ClawTranslator translator, FfunctionDefinition fctDef, List<Xnode> ranges, List<Xnode> statements, Xnode doStmtGrip) throws IllegalTransformationException {
    String[] inductionVars = new String[ranges.size()];
    Xnode[] doStmts = new Xnode[ranges.size()];
    Xnode var = statements.get(0).matchSeq(Xcode.F_ARRAY_REF, Xcode.VAR_REF, Xcode.VAR);
    if (var == null) {
        var = statements.get(0).matchSeq(Xcode.F_ARRAY_REF, Xcode.VAR_REF, Xcode.F_MEMBER_REF);
    }
    // 1. Create do statements with induction variables
    for (int i = 0; i < ranges.size(); ++i) {
        // 1.1 Create induction variables
        if (_clawStart.hasClause(ClawClause.INDUCTION)) {
            // Use user names
            inductionVars[i] = _clawStart.values(ClawClause.INDUCTION).get(i);
        } else {
            // generate new names
            inductionVars[i] = "claw_induction_" + translator.getNextTransformationCounter();
        }
        // 2.2 inject a new entry in the symbol table
        if (!fctDef.getSymbolTable().contains(inductionVars[i])) {
            Xid inductionVarId = xcodeml.createId(FortranType.INTEGER, XstorageClass.F_LOCAL, inductionVars[i]);
            fctDef.getSymbolTable().add(inductionVarId, false);
        }
        // 2.3 inject a new entry in the declaration table
        if (!fctDef.getDeclarationTable().contains(inductionVars[i])) {
            Xnode inductionVarDecl = xcodeml.createVarDecl(FortranType.INTEGER, inductionVars[i]);
            fctDef.getDeclarationTable().add(inductionVarDecl);
        }
        // 2.4 create do statements
        Xnode inductionVar = xcodeml.createVar(FortranType.INTEGER, inductionVars[i], Xscope.LOCAL);
        Xnode range;
        if (ranges.get(i).getBooleanAttribute(Xattr.IS_ASSUMED_SHAPE)) {
            // Allocatable array
            // dimension argument of size starts at one
            range = xcodeml.createRangeForAssumedShapeArray(var, 1, i + 1);
        } else {
            range = ranges.get(i).cloneNode();
        }
        doStmts[i] = xcodeml.createDoStmt(inductionVar, range);
        statements.get(0).copyEnhancedInfo(doStmts[i]);
        if (i == 0) {
            // most outer loop goes after the pragma
            doStmtGrip.insertAfter(doStmts[i]);
        } else {
            // others loop go in the previous one
            doStmts[i - 1].body().append(doStmts[i]);
        }
    }
    for (Xnode stmt : statements) {
        // 3. Adapt array reference with induction variables
        List<Xnode> allArrayRef = stmt.matchAll(Xcode.F_ARRAY_REF);
        for (Xnode arrayRef : allArrayRef) {
            for (int i = 0; i < arrayRef.children().size() - 1; ++i) {
                Xnode el = arrayRef.child(i + 1);
                if (Xnode.isOfCode(el, Xcode.INDEX_RANGE) && i < doStmts.length) {
                    String induction = doStmts[i].matchSeq(Xcode.VAR).value();
                    Xnode inductionVar = xcodeml.createVar(FortranType.INTEGER, induction, Xscope.LOCAL);
                    Xnode arrayIdx = xcodeml.createNode(Xcode.ARRAY_INDEX);
                    arrayIdx.append(inductionVar);
                    el.insertAfter(arrayIdx);
                    el.delete();
                }
            }
        }
        stmt.matchAll(Xcode.FUNCTION_CALL).stream().map(FunctionCall::new).filter(x -> x.isIntrinsicCall(Xintrinsic.SUM)).forEach(FunctionCall::adaptIntrinsicSumCall);
        stmt.matchAll(Xcode.FUNCTION_CALL).stream().map(FunctionCall::new).filter(x -> x.isIntrinsicCall(Xintrinsic.SPREAD)).forEach(FunctionCall::adaptIntrinsicSpreadCall);
        // 4. Move assignment statement inside the most inner loop
        doStmts[ranges.size() - 1].body().append(stmt, true);
        stmt.delete();
    }
    // Add any additional transformation defined in the directive clauses
    translator.generateAdditionalTransformation(_clawStart, xcodeml, doStmts[0]);
    return new Xblock(doStmts[0]);
}

Example 65 with Xnode

use of claw.tatsu.xcodeml.xnode.common.Xnode in project claw-compiler by C2SM-RCM.

the class ExpandNotation method generateSavepoint.

/**
 * Generate serialization savepoints before and after the expand block.
 *
 * @param xcodeml Current XcodeML translation unit.
 * @param hook    Block around which serialization are generated
 */
private Xblock generateSavepoint(Configuration cfg, XcodeProgram xcodeml, Xblock hook, List<String> readArrays, List<String> writtenArrays) {
    final Context context = xcodeml.context();
    Serialization.insertImports(cfg, xcodeml, hook.getStart().findParentFunction());
    Xnode start = null;
    Xnode end;
    if (context.isTarget(Target.GPU)) {
        // Read inputs
        start = Serialization.generateReadSavepoint(cfg, xcodeml, hook.getStart(), _clawStart.getMetadataMap(), readArrays, _clawStart.value(ClawClause.SAVEPOINT), SerializationStep.SER_IN);
    } else if (context.isTarget(Target.CPU)) {
        // Write inputs
        start = Serialization.generateWriteSavepoint(cfg, xcodeml, hook.getStart(), _clawStart.getMetadataMap(), readArrays, _clawStart.value(ClawClause.SAVEPOINT), SerializationStep.SER_IN);
    }
    // Write outputs
    end = Serialization.generateWriteSavepoint(cfg, xcodeml, hook.getEnd(), _clawStart.getMetadataMap(), writtenArrays, _clawStart.value(ClawClause.SAVEPOINT), SerializationStep.SER_OUT);
    return new Xblock(start, end);
}