polly/lib/External/ppcg/gpu_print.c - llvm-project - Git at Google

 /*
  * Copyright 2012      Ecole Normale Superieure
  *
  * Use of this software is governed by the MIT license
  *
  * Written by Sven Verdoolaege,
  * Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
  */

 #include <string.h>

 #include <isl/aff.h>

 #include "gpu_print.h"
 #include "print.h"
 #include "schedule.h"

 /* Print declarations to "p" for arrays that are local to "prog"
  * but that are used on the host and therefore require a declaration.
  */
 __isl_give isl_printer *gpu_print_local_declarations(__isl_take isl_printer *p,
 	struct gpu_prog *prog)
 {
 	int i;

 	if (!prog)
 		return isl_printer_free(p);

 	for (i = 0; i < prog->n_array; ++i) {
 		struct gpu_array_info *array = &prog->array[i];
 		isl_ast_expr *size;

 		if (!array->declare_local)
 			continue;
 		size = array->declared_size;
 		p = ppcg_print_declaration_with_size(p, array->type, size);
 	}

 	return p;
 }

 /* Print an expression for the size of "array" in bytes.
  */
 __isl_give isl_printer *gpu_array_info_print_size(__isl_take isl_printer *prn,
 	struct gpu_array_info *array)
 {
 	int i;

 	for (i = 0; i < array->n_index; ++i) {
 		isl_ast_expr *bound;

 		prn = isl_printer_print_str(prn, "(");
 		bound = isl_ast_expr_get_op_arg(array->bound_expr, 1 + i);
 		prn = isl_printer_print_ast_expr(prn, bound);
 		isl_ast_expr_free(bound);
 		prn = isl_printer_print_str(prn, ") * ");
 	}
 	prn = isl_printer_print_str(prn, "sizeof(");
 	prn = isl_printer_print_str(prn, array->type);
 	prn = isl_printer_print_str(prn, ")");

 	return prn;
 }

 /* Print the declaration of a non-linearized array argument.
  */
 static __isl_give isl_printer *print_non_linearized_declaration_argument(
 	__isl_take isl_printer *p, struct gpu_array_info *array)
 {
 	p = isl_printer_print_str(p, array->type);
 	p = isl_printer_print_str(p, " ");

 	p = isl_printer_print_ast_expr(p, array->bound_expr);

 	return p;
 }

 /* Print the declaration of an array argument.
  * "memory_space" allows to specify a memory space prefix.
  */
 __isl_give isl_printer *gpu_array_info_print_declaration_argument(
 	__isl_take isl_printer *p, struct gpu_array_info *array,
 	const char *memory_space)
 {
 	if (gpu_array_is_read_only_scalar(array)) {
 		p = isl_printer_print_str(p, array->type);
 		p = isl_printer_print_str(p, " ");
 		p = isl_printer_print_str(p, array->name);
 		return p;
 	}

 	if (memory_space) {
 		p = isl_printer_print_str(p, memory_space);
 		p = isl_printer_print_str(p, " ");
 	}

 	if (array->n_index != 0 && !array->linearize)
 		return print_non_linearized_declaration_argument(p, array);

 	p = isl_printer_print_str(p, array->type);
 	p = isl_printer_print_str(p, " ");
 	p = isl_printer_print_str(p, "*");
 	p = isl_printer_print_str(p, array->name);

 	return p;
 }

 /* Print the call of an array argument.
  */
 __isl_give isl_printer *gpu_array_info_print_call_argument(
 	__isl_take isl_printer *p, struct gpu_array_info *array)
 {
 	if (gpu_array_is_read_only_scalar(array))
 		return isl_printer_print_str(p, array->name);

 	p = isl_printer_print_str(p, "dev_");
 	p = isl_printer_print_str(p, array->name);

 	return p;
 }

 /* Print an access to the element in the private/shared memory copy
  * described by "stmt".  The index of the copy is recorded in
  * stmt->local_index as an access to the array.
  */
 static __isl_give isl_printer *stmt_print_local_index(__isl_take isl_printer *p,
 	struct ppcg_kernel_stmt *stmt)
 {
 	return isl_printer_print_ast_expr(p, stmt->u.c.local_index);
 }

 /* Print an access to the element in the global memory copy
  * described by "stmt".  The index of the copy is recorded in
  * stmt->index as an access to the array.
  */
 static __isl_give isl_printer *stmt_print_global_index(
 	__isl_take isl_printer *p, struct ppcg_kernel_stmt *stmt)
 {
 	struct gpu_array_info *array = stmt->u.c.array;
 	isl_ast_expr *index;

 	if (gpu_array_is_scalar(array)) {
 		if (!gpu_array_is_read_only_scalar(array))
 			p = isl_printer_print_str(p, "*");
 		p = isl_printer_print_str(p, array->name);
 		return p;
 	}

 	index = isl_ast_expr_copy(stmt->u.c.index);

 	p = isl_printer_print_ast_expr(p, index);
 	isl_ast_expr_free(index);

 	return p;
 }

 /* Print a copy statement.
  *
  * A read copy statement is printed as
  *
  *	local = global;
  *
  * while a write copy statement is printed as
  *
  *	global = local;
  */
 __isl_give isl_printer *ppcg_kernel_print_copy(__isl_take isl_printer *p,
 	struct ppcg_kernel_stmt *stmt)
 {
 	p = isl_printer_start_line(p);
 	if (stmt->u.c.read) {
 		p = stmt_print_local_index(p, stmt);
 		p = isl_printer_print_str(p, " = ");
 		p = stmt_print_global_index(p, stmt);
 	} else {
 		p = stmt_print_global_index(p, stmt);
 		p = isl_printer_print_str(p, " = ");
 		p = stmt_print_local_index(p, stmt);
 	}
 	p = isl_printer_print_str(p, ";");
 	p = isl_printer_end_line(p);

 	return p;
 }

 __isl_give isl_printer *ppcg_kernel_print_domain(__isl_take isl_printer *p,
 	struct ppcg_kernel_stmt *stmt)
 {
 	return pet_stmt_print_body(stmt->u.d.stmt->stmt, p, stmt->u.d.ref2expr);
 }

 /* This function is called for each node in a GPU AST.
  * In case of a user node, print the macro definitions required
  * for printing the AST expressions in the annotation, if any.
  * For other nodes, return true such that descendants are also
  * visited.
  *
  * In particular, for a kernel launch, print the macro definitions
  * needed for the grid size.
  * For a copy statement, print the macro definitions needed
  * for the two index expressions.
  * For an original user statement, print the macro definitions
  * needed for the substitutions.
  */
 static isl_bool at_node(__isl_keep isl_ast_node *node, void *user)
 {
 	const char *name;
 	isl_id *id;
 	int is_kernel;
 	struct ppcg_kernel *kernel;
 	struct ppcg_kernel_stmt *stmt;
 	isl_printer **p = user;

 	if (isl_ast_node_get_type(node) != isl_ast_node_user)
 		return isl_bool_true;

 	id = isl_ast_node_get_annotation(node);
 	if (!id)
 		return isl_bool_false;

 	name = isl_id_get_name(id);
 	if (!name)
 		return isl_bool_error;
 	is_kernel = !strcmp(name, "kernel");
 	kernel = is_kernel ? isl_id_get_user(id) : NULL;
 	stmt = is_kernel ? NULL : isl_id_get_user(id);
 	isl_id_free(id);

 	if ((is_kernel && !kernel) || (!is_kernel && !stmt))
 		return isl_bool_error;

 	if (is_kernel) {
 		*p = ppcg_ast_expr_print_macros(kernel->grid_size_expr, *p);
 	} else if (stmt->type == ppcg_kernel_copy) {
 		*p = ppcg_ast_expr_print_macros(stmt->u.c.index, *p);
 		*p = ppcg_ast_expr_print_macros(stmt->u.c.local_index, *p);
 	} else if (stmt->type == ppcg_kernel_domain) {
 		*p = ppcg_print_body_macros(*p, stmt->u.d.ref2expr);
 	}
 	if (!*p)
 		return isl_bool_error;

 	return isl_bool_false;
 }

 /* Print the required macros for the GPU AST "node" to "p",
  * including those needed for the user statements inside the AST.
  */
 __isl_give isl_printer *gpu_print_macros(__isl_take isl_printer *p,
 	__isl_keep isl_ast_node *node)
 {
 	if (isl_ast_node_foreach_descendant_top_down(node, &at_node, &p) < 0)
 		return isl_printer_free(p);
 	p = ppcg_print_macros(p, node);
 	return p;
 }

 /* Was the definition of "type" printed before?
  * That is, does its name appear in the list of printed types "types"?
  */
 static int already_printed(struct gpu_types *types,
 	struct pet_type *type)
 {
 	int i;

 	for (i = 0; i < types->n; ++i)
 		if (!strcmp(types->name[i], type->name))
 			return 1;

 	return 0;
 }

 /* Print the definitions of all types prog->scop that have not been
  * printed before (according to "types") on "p".
  * Extend the list of printed types "types" with the newly printed types.
  */
 __isl_give isl_printer *gpu_print_types(__isl_take isl_printer *p,
 	struct gpu_types *types, struct gpu_prog *prog)
 {
 	int i, n;
 	isl_ctx *ctx;
 	char **name;

 	n = prog->scop->pet->n_type;

 	if (n == 0)
 		return p;

 	ctx = isl_printer_get_ctx(p);
 	name = isl_realloc_array(ctx, types->name, char *, types->n + n);
 	if (!name)
 		return isl_printer_free(p);
 	types->name = name;

 	for (i = 0; i < n; ++i) {
 		struct pet_type *type = prog->scop->pet->types[i];

 		if (already_printed(types, type))
 			continue;

 		p = isl_printer_start_line(p);
 		p = isl_printer_print_str(p, type->definition);
 		p = isl_printer_print_str(p, ";");
 		p = isl_printer_end_line(p);

 		types->name[types->n++] = strdup(type->name);
 	}

 	return p;
 }
	/*
	* Copyright 2012 Ecole Normale Superieure
	*
	* Use of this software is governed by the MIT license
	*
	* Written by Sven Verdoolaege,
	* Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
	*/

	#include <string.h>

	#include <isl/aff.h>

	#include "gpu_print.h"
	#include "print.h"
	#include "schedule.h"

	/* Print declarations to "p" for arrays that are local to "prog"
	* but that are used on the host and therefore require a declaration.
	*/
	__isl_give isl_printer gpu_print_local_declarations(__isl_take isl_printer p,
	struct gpu_prog *prog)
	{
	int i;

	if (!prog)
	return isl_printer_free(p);

	for (i = 0; i < prog->n_array; ++i) {
	struct gpu_array_info *array = &prog->array[i];
	isl_ast_expr *size;

	if (!array->declare_local)
	continue;
	size = array->declared_size;
	p = ppcg_print_declaration_with_size(p, array->type, size);
	}

	return p;
	}

	/* Print an expression for the size of "array" in bytes.
	*/
	__isl_give isl_printer gpu_array_info_print_size(__isl_take isl_printer prn,
	struct gpu_array_info *array)
	{
	int i;

	for (i = 0; i < array->n_index; ++i) {
	isl_ast_expr *bound;

	prn = isl_printer_print_str(prn, "(");
	bound = isl_ast_expr_get_op_arg(array->bound_expr, 1 + i);
	prn = isl_printer_print_ast_expr(prn, bound);
	isl_ast_expr_free(bound);
	prn = isl_printer_print_str(prn, ") * ");
	}
	prn = isl_printer_print_str(prn, "sizeof(");
	prn = isl_printer_print_str(prn, array->type);
	prn = isl_printer_print_str(prn, ")");

	return prn;
	}

	/* Print the declaration of a non-linearized array argument.
	*/
	static __isl_give isl_printer *print_non_linearized_declaration_argument(
	__isl_take isl_printer p, struct gpu_array_info array)
	{
	p = isl_printer_print_str(p, array->type);
	p = isl_printer_print_str(p, " ");

	p = isl_printer_print_ast_expr(p, array->bound_expr);

	return p;
	}

	/* Print the declaration of an array argument.
	* "memory_space" allows to specify a memory space prefix.
	*/
	__isl_give isl_printer *gpu_array_info_print_declaration_argument(
	__isl_take isl_printer p, struct gpu_array_info array,
	const char *memory_space)
	{
	if (gpu_array_is_read_only_scalar(array)) {
	p = isl_printer_print_str(p, array->type);
	p = isl_printer_print_str(p, " ");
	p = isl_printer_print_str(p, array->name);
	return p;
	}

	if (memory_space) {
	p = isl_printer_print_str(p, memory_space);
	p = isl_printer_print_str(p, " ");
	}

	if (array->n_index != 0 && !array->linearize)
	return print_non_linearized_declaration_argument(p, array);

	p = isl_printer_print_str(p, array->type);
	p = isl_printer_print_str(p, " ");
	p = isl_printer_print_str(p, "*");
	p = isl_printer_print_str(p, array->name);

	return p;
	}

	/* Print the call of an array argument.
	*/
	__isl_give isl_printer *gpu_array_info_print_call_argument(
	__isl_take isl_printer p, struct gpu_array_info array)
	{
	if (gpu_array_is_read_only_scalar(array))
	return isl_printer_print_str(p, array->name);

	p = isl_printer_print_str(p, "dev_");
	p = isl_printer_print_str(p, array->name);

	return p;
	}

	/* Print an access to the element in the private/shared memory copy
	* described by "stmt". The index of the copy is recorded in
	* stmt->local_index as an access to the array.
	*/
	static __isl_give isl_printer stmt_print_local_index(__isl_take isl_printer p,
	struct ppcg_kernel_stmt *stmt)
	{
	return isl_printer_print_ast_expr(p, stmt->u.c.local_index);
	}

	/* Print an access to the element in the global memory copy
	* described by "stmt". The index of the copy is recorded in
	* stmt->index as an access to the array.
	*/
	static __isl_give isl_printer *stmt_print_global_index(
	__isl_take isl_printer p, struct ppcg_kernel_stmt stmt)
	{
	struct gpu_array_info *array = stmt->u.c.array;
	isl_ast_expr *index;

	if (gpu_array_is_scalar(array)) {
	if (!gpu_array_is_read_only_scalar(array))
	p = isl_printer_print_str(p, "*");
	p = isl_printer_print_str(p, array->name);
	return p;
	}

	index = isl_ast_expr_copy(stmt->u.c.index);

	p = isl_printer_print_ast_expr(p, index);
	isl_ast_expr_free(index);

	return p;
	}

	/* Print a copy statement.
	*
	* A read copy statement is printed as
	*
	* local = global;
	*
	* while a write copy statement is printed as
	*
	* global = local;
	*/
	__isl_give isl_printer ppcg_kernel_print_copy(__isl_take isl_printer p,
	struct ppcg_kernel_stmt *stmt)
	{
	p = isl_printer_start_line(p);
	if (stmt->u.c.read) {
	p = stmt_print_local_index(p, stmt);
	p = isl_printer_print_str(p, " = ");
	p = stmt_print_global_index(p, stmt);
	} else {
	p = stmt_print_global_index(p, stmt);
	p = isl_printer_print_str(p, " = ");
	p = stmt_print_local_index(p, stmt);
	}
	p = isl_printer_print_str(p, ";");
	p = isl_printer_end_line(p);

	return p;
	}

	__isl_give isl_printer ppcg_kernel_print_domain(__isl_take isl_printer p,
	struct ppcg_kernel_stmt *stmt)
	{
	return pet_stmt_print_body(stmt->u.d.stmt->stmt, p, stmt->u.d.ref2expr);
	}

	/* This function is called for each node in a GPU AST.
	* In case of a user node, print the macro definitions required
	* for printing the AST expressions in the annotation, if any.
	* For other nodes, return true such that descendants are also
	* visited.
	*
	* In particular, for a kernel launch, print the macro definitions
	* needed for the grid size.
	* For a copy statement, print the macro definitions needed
	* for the two index expressions.
	* For an original user statement, print the macro definitions
	* needed for the substitutions.
	*/
	static isl_bool at_node(__isl_keep isl_ast_node node, void user)
	{
	const char *name;
	isl_id *id;
	int is_kernel;
	struct ppcg_kernel *kernel;
	struct ppcg_kernel_stmt *stmt;
	isl_printer **p = user;

	if (isl_ast_node_get_type(node) != isl_ast_node_user)
	return isl_bool_true;

	id = isl_ast_node_get_annotation(node);
	if (!id)
	return isl_bool_false;

	name = isl_id_get_name(id);
	if (!name)
	return isl_bool_error;
	is_kernel = !strcmp(name, "kernel");
	kernel = is_kernel ? isl_id_get_user(id) : NULL;
	stmt = is_kernel ? NULL : isl_id_get_user(id);
	isl_id_free(id);

	if ((is_kernel && !kernel) \|\| (!is_kernel && !stmt))
	return isl_bool_error;

	if (is_kernel) {
	p = ppcg_ast_expr_print_macros(kernel->grid_size_expr, p);
	} else if (stmt->type == ppcg_kernel_copy) {
	p = ppcg_ast_expr_print_macros(stmt->u.c.index, p);
	p = ppcg_ast_expr_print_macros(stmt->u.c.local_index, p);
	} else if (stmt->type == ppcg_kernel_domain) {
	p = ppcg_print_body_macros(p, stmt->u.d.ref2expr);
	}
	if (!*p)
	return isl_bool_error;

	return isl_bool_false;
	}

	/* Print the required macros for the GPU AST "node" to "p",
	* including those needed for the user statements inside the AST.
	*/
	__isl_give isl_printer gpu_print_macros(__isl_take isl_printer p,
	__isl_keep isl_ast_node *node)
	{
	if (isl_ast_node_foreach_descendant_top_down(node, &at_node, &p) < 0)
	return isl_printer_free(p);
	p = ppcg_print_macros(p, node);
	return p;
	}

	/* Was the definition of "type" printed before?
	* That is, does its name appear in the list of printed types "types"?
	*/
	static int already_printed(struct gpu_types *types,
	struct pet_type *type)
	{
	int i;

	for (i = 0; i < types->n; ++i)
	if (!strcmp(types->name[i], type->name))
	return 1;

	return 0;
	}

	/* Print the definitions of all types prog->scop that have not been
	* printed before (according to "types") on "p".
	* Extend the list of printed types "types" with the newly printed types.
	*/
	__isl_give isl_printer gpu_print_types(__isl_take isl_printer p,
	struct gpu_types types, struct gpu_prog prog)
	{
	int i, n;
	isl_ctx *ctx;
	char **name;

	n = prog->scop->pet->n_type;

	if (n == 0)
	return p;

	ctx = isl_printer_get_ctx(p);
	name = isl_realloc_array(ctx, types->name, char *, types->n + n);
	if (!name)
	return isl_printer_free(p);
	types->name = name;

	for (i = 0; i < n; ++i) {
	struct pet_type *type = prog->scop->pet->types[i];

	if (already_printed(types, type))
	continue;

	p = isl_printer_start_line(p);
	p = isl_printer_print_str(p, type->definition);
	p = isl_printer_print_str(p, ";");
	p = isl_printer_end_line(p);

	types->name[types->n++] = strdup(type->name);
	}

	return p;
	}