CUDA Source Backend

CUDA source backend exports for CrossGL Translator.

CUDA AST Node definitions

class crosstl.backend.CUDA.CudaAst.AtomicOperationNode(operation, args)

Bases: FunctionCallNode

Node representing a CUDA atomic operation

class crosstl.backend.CUDA.CudaAst.ConstantMemoryNode(vtype, name, value=None)

Bases: VariableNode

Node representing constant memory variable declaration

class crosstl.backend.CUDA.CudaAst.CudaBuiltinNode(builtin_name, component=None)

Bases: ASTNode

Node representing CUDA built-in variables (threadIdx, blockIdx, etc.)

class crosstl.backend.CUDA.CudaAst.KernelLaunchNode(kernel_name, blocks, threads, shared_mem=None, stream=None, args=None)

Bases: ASTNode

Node representing a kernel launch: kernel<<<blocks, threads>>>(args)

class crosstl.backend.CUDA.CudaAst.KernelNode(return_type, name, params, body, attributes=None)

Bases: FunctionNode

Node representing a CUDA kernel function (marked with __global__)

class crosstl.backend.CUDA.CudaAst.SharedMemoryNode(vtype, name, size=None)

Bases: VariableNode

Node representing shared memory variable declaration

class crosstl.backend.CUDA.CudaAst.TextureAccessNode(texture_name, coordinates)

Bases: ASTNode

Node representing texture memory access

Lexer for importing CUDA source into CrossGL Translator.

class crosstl.backend.CUDA.CudaLexer.CudaLexer(code)

Bases: object

Tokenize CUDA source for the CUDA backend parser.

classmethod from_file(filepath)

Create a lexer instance from a file

Return type:

CudaLexer

token_generator()

Generator function that yields tokens one at a time

Return type:

Iterator[Tuple[str, str]]

tokenize()

Tokenize the input code and return list of tokens

Return type:

List[Tuple[str, str]]

class crosstl.backend.CUDA.CudaLexer.Lexer(input_str)

Bases: object

Compatibility wrapper around CudaLexer

next()

Return the next token and advance the cursor.

peek()

Return the next token without advancing the cursor.

class crosstl.backend.CUDA.CudaLexer.TokenType(value)

Bases: Enum

Token names emitted by the CUDA lexer.

CUDA Parser Implementation

class crosstl.backend.CUDA.CudaParser.CudaParser(tokens)

Bases: object

Parse CUDA tokens into the CUDA backend shader AST.

eat(expected_type)

Consume a token of the expected type

is_range_for_statement()

Check if the current parenthesized for header is a range-for loop.

is_variable_declaration()

Check if current position is a variable declaration

parse()

Parse the entire CUDA program into a ShaderNode.

parse_additive_expression()

Parse additive expression

parse_array_suffix()

Parse one or more C-style array declarator suffixes.

parse_assignment_expression()

Parse assignment expression

parse_bitwise_and_expression()

Parse bitwise AND expression

parse_bitwise_or_expression()

Parse bitwise OR expression

parse_bitwise_xor_expression()

Parse bitwise XOR expression

parse_block()

Parse a block of statements

parse_do_while_statement()

Parse do-while loop

parse_equality_expression()

Parse equality expression

parse_expression()

Parse expression with precedence

parse_for_statement()

Parse for loop

parse_function()

Parse function declaration including kernels

parse_global_variable()

Parse global variable declaration

parse_if_statement()

Parse if statement

parse_kernel_launch(kernel_name)

Parse CUDA kernel launch syntax

parse_logical_and_expression()

Parse logical AND expression

parse_logical_or_expression()

Parse logical OR expression

parse_multiplicative_expression()

Parse multiplicative expression

parse_parameter()

Parse a single parameter

parse_parameters()

Parse function parameters

parse_postfix_expression()

Parse postfix expression

parse_preprocessor()

Parse preprocessor directives

parse_primary_expression()

Parse primary expression

parse_range_for_statement()

Parse a C++ range-based for loop after ‘for (’ has been consumed.

parse_relational_expression()

Parse relational expression

parse_return_statement()

Parse return statement

parse_shift_expression()

Parse bit shift expression

parse_statement()

Parse a single statement

parse_struct()

Parse struct declaration

parse_switch_statement()

Parse switch statement

parse_sync_statement()

Parse CUDA synchronization statements

parse_ternary_expression()

Parse ternary conditional operator

parse_type()

Parse type specification

parse_unary_expression()

Parse unary expression

parse_variable_declaration()

Parse variable declaration

parse_variable_declaration_list()

Parse one or more comma-separated variable declarations.

parse_while_statement()

Parse while loop

peek_function()

Check if the next tokens form a function declaration

peek_variable()

Check if the next tokens form a variable declaration

CUDA to CrossGL Code Generator

class crosstl.backend.CUDA.CudaCrossGLCodeGen.CudaToCrossGLConverter

Bases: object

Serialize CUDA backend AST nodes back into CrossGL source.

convert_cuda_builtin_function(func_name)

Convert CUDA built-in functions to CrossGL equivalents.

convert_cuda_pointer_type(cuda_type)

Convert a CUDA pointer type into nested CrossGL pointer syntax.

convert_cuda_type_to_crossgl(cuda_type)

Convert CUDA types to CrossGL equivalents

emit(code)

Append a line of CrossGL output using the current indentation level.

emit_statement(stmt)

Render and append one converted statement.

generate(ast_node)

Generate complete CrossGL source from a parsed CUDA AST.

generic_visit(node)

Fallback converter for primitive values, lists, and unknown nodes.

visit(node)

Dispatch a CUDA backend AST node to its converter method.

visit_FunctionNode(node)

Render a CUDA function node as a CrossGL function.

visit_ShaderNode(node)

Render a CUDA shader/program AST as a CrossGL shader block.

visit_kernel_as_compute_shader(kernel)

Render a CUDA kernel as a CrossGL compute shader block.