From bd9e3ecce0640a8185639bb49a983fe22b72e578 Mon Sep 17 00:00:00 2001 From: Gnimuc Date: Sun, 18 Aug 2024 20:21:48 +0900 Subject: [PATCH 1/6] Adapt to Clang16's base class name printing policy --- deps/generate_wrapper.jl | 40 +++++++++++++++++++++++++++++++++++----- 1 file changed, 35 insertions(+), 5 deletions(-) diff --git a/deps/generate_wrapper.jl b/deps/generate_wrapper.jl index 7be0447..430b794 100644 --- a/deps/generate_wrapper.jl +++ b/deps/generate_wrapper.jl @@ -46,7 +46,7 @@ resolve_headers(headers::Vector{String}, include_paths::Vector{String})::Vector{ resolve_header.(headers, Ref(include_paths)) function get_full_name(cursor, funcargs::Bool=true, buf="") - parent = Clang.getCursorLexicalParent(cursor) + parent = Clang.getCursorSemanticParent(cursor) parent_kind = spelling(kind(parent)) cursor_name = name(cursor) if !funcargs @@ -111,6 +111,36 @@ function get_julia_name(cursor::CLCursor) replace(vname, "::" => "") end +nns(x::Clang.CLInvalidFile) = "" +nns(x::Clang.CLTranslationUnit) = "" +function nns(x::CLCursor) + pn = nns(Clang.getCursorSemanticParent(x)) + if isempty(pn) + return spelling(x) + else + return pn * "::" * spelling(x) + end +end +get_qualified_name(x::CLCursor) = isempty(spelling(x)) ? "" : nns(x) + +get_qualified_basename(x::CLCursor) = "" +function get_qualified_basename(x::CLTypeRef) + n = spelling(x) + startswith(n, "class ") && return split(n, "class ")[2] + startswith(n, "struct ") && return split(n, "struct ")[2] + startswith(n, "Union ") && return split(n, "Union ")[2] + return "" +end +get_qualified_basename(x::CLCXXBaseSpecifier) = get_qualified_basename(children(x)[1]) +function get_qualified_basename(x::Union{CLClassDecl,CLStructDecl,CLUnionDecl}) + bn = get_qualified_basename(children(x)[1]) + if isempty(bn) + return spelling(x) + else + return bn * "::" * spelling(x) + end +end + function object_decl_handler(ctx::BindgenContext, classdecl::CLCursor)::Tuple{Union{Nothing, String}, Union{Nothing, String}} full_name = get_full_name(classdecl) length(children(classdecl)) == 0 && return nothing, "skip_empty_classdecl" @@ -123,10 +153,10 @@ function object_decl_handler(ctx::BindgenContext, classdecl::CLCursor)::Tuple{Un end # handle simple inheritance - if length(children(classdecl)) > 1 && kind(children(classdecl)[1]) == Clang.CXCursor_CXXBaseSpecifier - - if startswith(get_full_name(children(classdecl)[1]), "class ") - base_class = split(get_full_name(children(classdecl)[1]), "class ")[2] + subnodes = children(classdecl) + if length(subnodes) > 1 && kind(subnodes[1]) == Clang.CXCursor_CXXBaseSpecifier + base_class = get_qualified_basename(subnodes[1]) + if !isempty(base_class) ctx.outputSupertypes *= "template<> struct SuperType<$full_name> { typedef $base_class type; };\n" From 85bfcfb4107034930c2027fbb9f1e0a2413e526c Mon Sep 17 00:00:00 2001 From: Gnimuc Date: Tue, 20 Aug 2024 22:26:41 +0900 Subject: [PATCH 2/6] 3.2 --- deps/wrapper/gen_headers.hpp | 8 + deps/wrapper/gen_inherit.cpp | 61 + deps/wrapper/gen_inline.cpp | 3177 ++++++++++++++++++++++++++++++++++ 3 files changed, 3246 insertions(+) create mode 100644 deps/wrapper/gen_headers.hpp create mode 100644 deps/wrapper/gen_inherit.cpp create mode 100644 deps/wrapper/gen_inline.cpp diff --git a/deps/wrapper/gen_headers.hpp b/deps/wrapper/gen_headers.hpp new file mode 100644 index 0000000..f212c35 --- /dev/null +++ b/deps/wrapper/gen_headers.hpp @@ -0,0 +1,8 @@ +#include +#include +#include +#include +#include +#include +#include +#include diff --git a/deps/wrapper/gen_inherit.cpp b/deps/wrapper/gen_inherit.cpp new file mode 100644 index 0000000..18d7ddf --- /dev/null +++ b/deps/wrapper/gen_inherit.cpp @@ -0,0 +1,61 @@ +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::runtime_error type; }; +template<> struct SuperType { typedef poplar::runtime_error type; }; +template<> struct SuperType { typedef poplar::system_runtime_error type; }; +template<> struct SuperType { typedef poplar::system_runtime_error type; }; +template<> struct SuperType { typedef poplar::system_runtime_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::program::Program type; }; +template<> struct SuperType { typedef poplar::program::Program type; }; +template<> struct SuperType { typedef poplar::program::Program type; }; +template<> struct SuperType { typedef poplar::program::Program type; }; +template<> struct SuperType { typedef poplar::program::Program type; }; +template<> struct SuperType { typedef poplar::program::Program type; }; +template<> struct SuperType { typedef poplar::program::Program type; }; +template<> struct SuperType { typedef poplar::program::Program type; }; +template<> struct SuperType { typedef poplar::program::Program type; }; +template<> struct SuperType { typedef poplar::program::Program type; }; +template<> struct SuperType { typedef poplar::program::Program type; }; +template<> struct SuperType { typedef poplar::program::Program type; }; +template<> struct SuperType { typedef poplar::program::Program type; }; +template<> struct SuperType { typedef poplar::program::Program type; }; +template<> struct SuperType { typedef poplar::program::Program type; }; +template<> struct SuperType { typedef poplar::program::Program type; }; +template<> struct SuperType { typedef poplar::program::Program type; }; +template<> struct SuperType { typedef poplar::program::Program type; }; +template<> struct SuperType { typedef poplar::program::Program type; }; +template<> struct SuperType { typedef poplar::StreamCallbackBase type; }; +template<> struct SuperType { typedef poplar::StreamCallback type; }; +template<> struct SuperType { typedef poplar::StreamCallback type; }; +template<> struct SuperType { typedef poplar::StreamCallback type; }; diff --git a/deps/wrapper/gen_inline.cpp b/deps/wrapper/gen_inline.cpp new file mode 100644 index 0000000..643d10c --- /dev/null +++ b/deps/wrapper/gen_inline.cpp @@ -0,0 +1,3177 @@ +// poplar::layout::Vector__EnumDecl +mod.add_bits("LayoutVector", jlcxx::julia_type("CppEnum")); +// poplar::layout::VectorList__EnumDecl +mod.add_bits("LayoutVectorList", jlcxx::julia_type("CppEnum")); +// std::string__StructDecl +auto JLStringRef = mod.add_type("StringRef"); +// poplar::OptionFlags__ClassDecl +auto JLOptionFlags = mod.add_type("OptionFlags"); +// poplar::OptionFlags::iterator__ClassDecl +auto JLOptionFlagsiterator = mod.add_type("OptionFlagsiterator"); +// poplar::GlobalExchangeFlow__StructDecl +auto JLGlobalExchangeFlow = mod.add_type("GlobalExchangeFlow"); +// poplar::GlobalExchangeConstraint__StructDecl +auto JLGlobalExchangeConstraint = mod.add_type("GlobalExchangeConstraint"); +// poplar::IpuLinkConfiguration__EnumDecl +mod.add_bits("PoplarIpuLinkConfiguration", jlcxx::julia_type("CppEnum")); +// poplar::IpuLinkTopology__EnumDecl +mod.add_bits("PoplarIpuLinkTopology", jlcxx::julia_type("CppEnum")); +// poplar::TargetType__EnumDecl +mod.add_bits("PoplarTargetType", jlcxx::julia_type("CppEnum")); +// poplar::Type__ClassDecl +auto JLType = mod.add_type("Type_"); +// poplar::Target__ClassDecl +auto JLTarget = mod.add_type("Target"); +// poplar::Device__ClassDecl +auto JLDevice = mod.add_type("Device"); +// poplar::DeviceManager__ClassDecl +auto JLDeviceManager = mod.add_type("DeviceManager"); +// poplar::Executable__ClassDecl +auto JLExecutable = mod.add_type("Executable"); +// poplar::CodeletFileType__EnumDecl +mod.add_bits("PoplarCodeletFileType", jlcxx::julia_type("CppEnum")); +// poplar::DataStreamType__EnumDecl +mod.add_bits("PoplarDataStreamType", jlcxx::julia_type("CppEnum")); +// poplar::ReplicatedStreamMode__EnumDecl +mod.add_bits("PoplarReplicatedStreamMode", jlcxx::julia_type("CppEnum")); +// poplar::DataStream__ClassDecl +auto JLDataStream = mod.add_type("DataStream"); +// poplar::RemoteBuffer__ClassDecl +auto JLRemoteBuffer = mod.add_type("RemoteBuffer"); +// poplar::ProfileValue__ClassDecl +auto JLProfileValue = mod.add_type("ProfileValue"); +// poplar::ProfileValue::Type__EnumDecl +mod.add_bits("ProfileValueType", jlcxx::julia_type("CppEnum")); +// poplar::ProfileValue::Storage__StructDecl +auto JLProfileValueStorage = mod.add_type("ProfileValueStorage"); +// poplar::SerializationFormat__EnumDecl +mod.add_bits("PoplarSerializationFormat", jlcxx::julia_type("CppEnum")); +// poplar::SourceLocation__ClassDecl +auto JLSourceLocation = mod.add_type("SourceLocation"); +// poplar::DebugSerializationFormat__EnumDecl +mod.add_bits("PoplarDebugSerializationFormat", jlcxx::julia_type("CppEnum")); +// poplar::DebugInfo__ClassDecl +auto JLDebugInfo = mod.add_type("DebugInfo"); +// poplar::DebugNameAndId__ClassDecl +auto JLDebugNameAndId = mod.add_type("DebugNameAndId"); +// poplar::DebugContext__ClassDecl +auto JLDebugContext = mod.add_type("DebugContext"); +// poplar::FunctionBufferMappingType__EnumDecl +mod.add_bits("PoplarFunctionBufferMappingType", jlcxx::julia_type("CppEnum")); +// poplar::VertexRef__ClassDecl +auto JLVertexRef = mod.add_type("VertexRef"); +// poplar::FieldRef__ClassDecl +auto JLFieldRef = mod.add_type("FieldRef"); +// poplar::ComputeSet__ClassDecl +auto JLComputeSet = mod.add_type("ComputeSet"); +// poplar::Function__ClassDecl +auto JLFunction = mod.add_type("Function"); +// poplar::FunctionBuffer__ClassDecl +auto JLFunctionBuffer = mod.add_type("FunctionBuffer"); +// poplar::HostFunction__ClassDecl +auto JLHostFunction = mod.add_type("HostFunction"); +// poplar::ErrorCode__EnumDecl +mod.add_bits("PoplarErrorCode", jlcxx::julia_type("CppEnum")); +// poplar::ErrorLocation__StructDecl +auto JLErrorLocation = mod.add_type("ErrorLocation"); +// poplar::poplar_error__StructDecl +auto JLPoplar_error = mod.add_type("Poplar_error"); +// poplar::graph_program_compilation_error__StructDecl +auto JLGraph_program_compilation_error = mod.add_type("Graph_program_compilation_error", jlcxx::julia_base_type()); +// poplar::graph_object_creation_error__StructDecl +auto JLGraph_object_creation_error = mod.add_type("Graph_object_creation_error", jlcxx::julia_base_type()); +// poplar::graph_object_load_error__StructDecl +auto JLGraph_object_load_error = mod.add_type("Graph_object_load_error", jlcxx::julia_base_type()); +// poplar::no_environment__StructDecl +auto JLNo_environment = mod.add_type("No_environment", jlcxx::julia_base_type()); +// poplar::unknown_vertex_type__StructDecl +auto JLUnknown_vertex_type = mod.add_type("Unknown_vertex_type", jlcxx::julia_base_type()); +// poplar::unknown_field__StructDecl +auto JLUnknown_field = mod.add_type("Unknown_field", jlcxx::julia_base_type()); +// poplar::control_program_error__StructDecl +auto JLControl_program_error = mod.add_type("Control_program_error", jlcxx::julia_base_type()); +// poplar::type_error__StructDecl +auto JLType_error = mod.add_type("Type_error", jlcxx::julia_base_type()); +// poplar::index_error__StructDecl +auto JLIndex_error = mod.add_type("Index_error", jlcxx::julia_base_type()); +// poplar::no_size_specified__StructDecl +auto JLNo_size_specified = mod.add_type("No_size_specified", jlcxx::julia_base_type()); +// poplar::graph_connection_error__StructDecl +auto JLGraph_connection_error = mod.add_type("Graph_connection_error", jlcxx::julia_base_type()); +// poplar::graph_cycle_error__StructDecl +auto JLGraph_cycle_error = mod.add_type("Graph_cycle_error", jlcxx::julia_base_type()); +// poplar::graph_recursion_error__StructDecl +auto JLGraph_recursion_error = mod.add_type("Graph_recursion_error", jlcxx::julia_base_type()); +// poplar::graph_replication_error__StructDecl +auto JLGraph_replication_error = mod.add_type("Graph_replication_error", jlcxx::julia_base_type()); +// poplar::profiling_disabled__StructDecl +auto JLProfiling_disabled = mod.add_type("Profiling_disabled", jlcxx::julia_base_type()); +// poplar::missing_graph_profile__StructDecl +auto JLMissing_graph_profile = mod.add_type("Missing_graph_profile", jlcxx::julia_base_type()); +// poplar::missing_perf_estimate__StructDecl +auto JLMissing_perf_estimate = mod.add_type("Missing_perf_estimate", jlcxx::julia_base_type()); +// poplar::invalid_tile_mapping__StructDecl +auto JLInvalid_tile_mapping = mod.add_type("Invalid_tile_mapping", jlcxx::julia_base_type()); +// poplar::tensor_creation_error__StructDecl +auto JLTensor_creation_error = mod.add_type("Tensor_creation_error", jlcxx::julia_base_type()); +// poplar::tensor_io_state_error__StructDecl +auto JLTensor_io_state_error = mod.add_type("Tensor_io_state_error", jlcxx::julia_base_type()); +// poplar::tensor_metadata_error__StructDecl +auto JLTensor_metadata_error = mod.add_type("Tensor_metadata_error", jlcxx::julia_base_type()); +// poplar::stream_connection_error__StructDecl +auto JLStream_connection_error = mod.add_type("Stream_connection_error", jlcxx::julia_base_type()); +// poplar::overflow_error__StructDecl +auto JLOverflow_error = mod.add_type("Overflow_error", jlcxx::julia_base_type()); +// poplar::memory_elem_constraints_error__StructDecl +auto JLMemory_elem_constraints_error = mod.add_type("Memory_elem_constraints_error", jlcxx::julia_base_type()); +// poplar::graph_memory_allocation_error__StructDecl +auto JLGraph_memory_allocation_error = mod.add_type("Graph_memory_allocation_error", jlcxx::julia_base_type()); +// poplar::stream_memory_allocation_error__StructDecl +auto JLStream_memory_allocation_error = mod.add_type("Stream_memory_allocation_error", jlcxx::julia_base_type()); +// poplar::invalid_machine_model__StructDecl +auto JLInvalid_machine_model = mod.add_type("Invalid_machine_model", jlcxx::julia_base_type()); +// poplar::invalid_option__StructDecl +auto JLInvalid_option = mod.add_type("Invalid_option", jlcxx::julia_base_type()); +// poplar::link_error__StructDecl +auto JLLink_error = mod.add_type("Link_error", jlcxx::julia_base_type()); +// poplar::runtime_error__StructDecl +auto JLRuntime_error = mod.add_type("Runtime_error", jlcxx::julia_base_type()); +// poplar::runtime_error::ErrorInfo__StructDecl +auto JLRuntime_errorErrorInfo = mod.add_type("Runtime_errorErrorInfo"); +// poplar::application_runtime_error__StructDecl +auto JLApplication_runtime_error = mod.add_type("Application_runtime_error", jlcxx::julia_base_type()); +// poplar::system_runtime_error__StructDecl +auto JLSystem_runtime_error = mod.add_type("System_runtime_error", jlcxx::julia_base_type()); +// poplar::RecoveryAction__EnumDecl +mod.add_bits("PoplarRecoveryAction", jlcxx::julia_type("CppEnum")); +// poplar::recoverable_runtime_error__StructDecl +auto JLRecoverable_runtime_error = mod.add_type("Recoverable_runtime_error", jlcxx::julia_base_type()); +// poplar::unrecoverable_runtime_error__StructDecl +auto JLUnrecoverable_runtime_error = mod.add_type("Unrecoverable_runtime_error", jlcxx::julia_base_type()); +// poplar::unknown_runtime_error__StructDecl +auto JLUnknown_runtime_error = mod.add_type("Unknown_runtime_error", jlcxx::julia_base_type()); +// poplar::symbol_error__StructDecl +auto JLSymbol_error = mod.add_type("Symbol_error", jlcxx::julia_base_type()); +// poplar::file_load_error__StructDecl +auto JLFile_load_error = mod.add_type("File_load_error", jlcxx::julia_base_type()); +// poplar::parse_error__StructDecl +auto JLParse_error = mod.add_type("Parse_error", jlcxx::julia_base_type()); +// poplar::VertexEdgeInfo__StructDecl +auto JLVertexEdgeInfo = mod.add_type("VertexEdgeInfo"); +// poplar::VertexEdgeInfo::StorageInfo__StructDecl +auto JLVertexEdgeInfoStorageInfo = mod.add_type("VertexEdgeInfoStorageInfo"); +// poplar::VertexPerfEstimate__StructDecl +mod.map_type("VertexPerfEstimate"); +// poplar::SyncType__EnumDecl +mod.add_bits("PoplarSyncType", jlcxx::julia_type("CppEnum")); +// poplar::TypeTraits__StructDecl +auto JLTypeTraits = mod.add_type("TypeTraits"); +// poplar::UpsampleMethod__EnumDecl +mod.add_bits("PoplarUpsampleMethod", jlcxx::julia_type("CppEnum")); +// poplar::Tensor__ClassDecl +auto JLTensor = mod.add_type("Tensor"); +// poplar::program::Program__ClassDecl +auto JLProgramProgram = mod.add_type("ProgramProgram"); +// poplar::program::Execute__ClassDecl +auto JLProgramExecute = mod.add_type("ProgramExecute", jlcxx::julia_base_type()); +// poplar::program::Sequence__ClassDecl +auto JLProgramSequence = mod.add_type("ProgramSequence", jlcxx::julia_base_type()); +// poplar::program::Repeat__ClassDecl +auto JLProgramRepeat = mod.add_type("ProgramRepeat", jlcxx::julia_base_type()); +// poplar::program::RepeatWhileFalse__ClassDecl +auto JLProgramRepeatWhileFalse = mod.add_type("ProgramRepeatWhileFalse", jlcxx::julia_base_type()); +// poplar::program::RepeatWhileTrue__ClassDecl +auto JLProgramRepeatWhileTrue = mod.add_type("ProgramRepeatWhileTrue", jlcxx::julia_base_type()); +// poplar::program::Loop__ClassDecl +auto JLProgramLoop = mod.add_type("ProgramLoop", jlcxx::julia_base_type()); +// poplar::program::If__ClassDecl +auto JLProgramIf = mod.add_type("ProgramIf", jlcxx::julia_base_type()); +// poplar::program::Switch__ClassDecl +auto JLProgramSwitch = mod.add_type("ProgramSwitch", jlcxx::julia_base_type()); +// poplar::program::Copy__ClassDecl +auto JLProgramCopy = mod.add_type("ProgramCopy", jlcxx::julia_base_type()); +// poplar::program::CrossReplicaCopy__ClassDecl +auto JLProgramCrossReplicaCopy = mod.add_type("ProgramCrossReplicaCopy", jlcxx::julia_base_type()); +// poplar::program::WriteUndef__ClassDecl +auto JLProgramWriteUndef = mod.add_type("ProgramWriteUndef", jlcxx::julia_base_type()); +// poplar::program::AssumeEqualAcrossReplicas__ClassDecl +auto JLProgramAssumeEqualAcrossReplicas = mod.add_type("ProgramAssumeEqualAcrossReplicas", jlcxx::julia_base_type()); +// poplar::program::Block__ClassDecl +auto JLProgramBlock = mod.add_type("ProgramBlock", jlcxx::julia_base_type()); +// poplar::program::Sync__ClassDecl +auto JLProgramSync = mod.add_type("ProgramSync", jlcxx::julia_base_type()); +// poplar::program::Call__ClassDecl +auto JLProgramCall = mod.add_type("ProgramCall", jlcxx::julia_base_type()); +// poplar::program::PrintTensor__ClassDecl +auto JLProgramPrintTensor = mod.add_type("ProgramPrintTensor", jlcxx::julia_base_type()); +// poplar::program::ErrorProgram__ClassDecl +auto JLProgramErrorProgram = mod.add_type("ProgramErrorProgram", jlcxx::julia_base_type()); +// poplar::program::Abort__ClassDecl +auto JLProgramAbort = mod.add_type("ProgramAbort", jlcxx::julia_base_type()); +// poplar::program::AbortOnCondition__ClassDecl +auto JLProgramAbortOnCondition = mod.add_type("ProgramAbortOnCondition", jlcxx::julia_base_type()); +// poplar::TensorCloneMethod__EnumDecl +mod.add_bits("PoplarTensorCloneMethod", jlcxx::julia_type("CppEnum")); +// poplar::TensorCloneDuplicationMethod__EnumDecl +mod.add_bits("PoplarTensorCloneDuplicationMethod", jlcxx::julia_type("CppEnum")); +// poplar::TensorRearranger__ClassDecl +auto JLTensorRearranger = mod.add_type("TensorRearranger"); +// poplar::VariableMappingMethod__EnumDecl +mod.add_bits("PoplarVariableMappingMethod", jlcxx::julia_type("CppEnum")); +// poplar::VariableRef__ClassDecl +auto JLVariableRef = mod.add_type("VariableRef"); +// poplar::VariableInterval__StructDecl +auto JLVariableInterval = mod.add_type("VariableInterval"); +// poplar::FieldData__ClassDecl +auto JLFieldData = mod.add_type("FieldData"); +// poplar::FieldData::SizeT__StructDecl +auto JLFieldDataSizeT = mod.add_type("FieldDataSizeT"); +// poplar::replication_factor__StructDecl +auto JLReplication_factor = mod.add_type("Replication_factor"); +// poplar::Graph__ClassDecl +auto JLGraph = mod.add_type("Graph"); +// poplar::Graph::ConnectionDesc__ClassDecl +auto JLGraphConnectionDesc = mod.add_type("GraphConnectionDesc"); +// poplar::HostCallback__ClassDecl +auto JLHostCallback = mod.add_type("HostCallback"); +// poplar::HostCallbackHandle__ClassDecl +auto JLHostCallbackHandle = mod.add_type("HostCallbackHandle"); +// poplar::Module__ClassDecl +auto JLModule = mod.add_type("Module"); +// poplar::RuntimeOptions__ClassDecl +auto JLRuntimeOptions = mod.add_type("RuntimeOptions"); +// poplar::StreamCallbackBase__ClassDecl +auto JLStreamCallbackBase = mod.add_type("StreamCallbackBase"); +// poplar::StreamCallbackBase::Result__EnumDecl +mod.add_bits("StreamCallbackBaseResult", jlcxx::julia_type("CppEnum")); +// poplar::StreamCallback__ClassDecl +auto JLStreamCallback = mod.add_type("StreamCallback", jlcxx::julia_base_type()); +// poplar::StreamCallbackWithMetadata__ClassDecl +auto JLStreamCallbackWithMetadata = mod.add_type("StreamCallbackWithMetadata", jlcxx::julia_base_type()); +// poplar::ResumableStreamCallback__ClassDecl +auto JLResumableStreamCallback = mod.add_type("ResumableStreamCallback", jlcxx::julia_base_type()); +// poplar::LegacyStreamCallback__ClassDecl +auto JLLegacyStreamCallback = mod.add_type("LegacyStreamCallback", jlcxx::julia_base_type()); +// poplar::StreamCallbackHandle__ClassDecl +auto JLStreamCallbackHandle = mod.add_type("StreamCallbackHandle"); +// poplar::Engine__ClassDecl +auto JLEngine = mod.add_type("Engine"); +// poplar::Engine::TimerTimePoint__ClassDecl +auto JLEngineTimerTimePoint = mod.add_type("EngineTimerTimePoint"); +// poplar::FloatingPointBehaviour__StructDecl +auto JLFloatingPointBehaviour = mod.add_type("FloatingPointBehaviour"); +// poplar::IPUModel__StructDecl +auto JLIPUModel = mod.add_type("IPUModel"); +// poplar::IPUModel::RelativeSyncDelayType__EnumDecl +mod.add_bits("IPUModelRelativeSyncDelayType", jlcxx::julia_type("CppEnum")); +// poplar::layout::Vector::NotAVector__EnumConstantDecl +mod.set_const("LayoutVectorLayoutNotAVector", poplar::layout::Vector::NotAVector); +// poplar::layout::Vector::Span__EnumConstantDecl +mod.set_const("LayoutVectorLayoutSpan", poplar::layout::Vector::Span); +// poplar::layout::Vector::ShortSpan__EnumConstantDecl +mod.set_const("LayoutVectorLayoutShortSpan", poplar::layout::Vector::ShortSpan); +// poplar::layout::Vector::OnePtr__EnumConstantDecl +mod.set_const("LayoutVectorLayoutOnePtr", poplar::layout::Vector::OnePtr); +// poplar::layout::Vector::ScaledPtr32__EnumConstantDecl +mod.set_const("LayoutVectorLayoutScaledPtr32", poplar::layout::Vector::ScaledPtr32); +// poplar::layout::Vector::ScaledPtr64__EnumConstantDecl +mod.set_const("LayoutVectorLayoutScaledPtr64", poplar::layout::Vector::ScaledPtr64); +// poplar::layout::Vector::ScaledPtr128__EnumConstantDecl +mod.set_const("LayoutVectorLayoutScaledPtr128", poplar::layout::Vector::ScaledPtr128); +// poplar::layout::to_string(const poplar::layout::Vector)__FunctionDecl +{ using namespace poplar::layout; +mod.method("LayoutTo_String", [](const poplar::layout::Vector a) {return poplar::layout::to_string(a);} ); } +// poplar::layout::VectorList::NotAVector__EnumConstantDecl +mod.set_const("LayoutVectorListLayoutNotAVector", poplar::layout::VectorList::NotAVector); +// poplar::layout::VectorList::OnePtr__EnumConstantDecl +mod.set_const("LayoutVectorListLayoutOnePtr", poplar::layout::VectorList::OnePtr); +// poplar::layout::VectorList::ScaledPtr32__EnumConstantDecl +mod.set_const("LayoutVectorListLayoutScaledPtr32", poplar::layout::VectorList::ScaledPtr32); +// poplar::layout::VectorList::ScaledPtr64__EnumConstantDecl +mod.set_const("LayoutVectorListLayoutScaledPtr64", poplar::layout::VectorList::ScaledPtr64); +// poplar::layout::VectorList::ScaledPtr128__EnumConstantDecl +mod.set_const("LayoutVectorListLayoutScaledPtr128", poplar::layout::VectorList::ScaledPtr128); +// poplar::layout::VectorList::DeltaN__EnumConstantDecl +mod.set_const("LayoutVectorListLayoutDeltaN", poplar::layout::VectorList::DeltaN); +// poplar::layout::VectorList::DeltaNElements__EnumConstantDecl +mod.set_const("LayoutVectorListLayoutDeltaNElements", poplar::layout::VectorList::DeltaNElements); +// std::string::StringRef(const std::string &)__CXXConstructor +{ using namespace poplar; +JLStringRef.constructor(); +} +// std::string::StringRef(const char *, std::size_t)__CXXConstructor +{ using namespace poplar; +JLStringRef.constructor(); +} +// std::string::StringRef(const char *)__CXXConstructor +{ using namespace poplar; +JLStringRef.constructor(); +} +// std::string::cloneAsString()__CXXMethod +{ using namespace poplar; +JLStringRef.method("StringRefCloneAsString", [](poplar::StringRef& cl) {return cl.cloneAsString();}); +} +// poplar::OptionFlags::iterator::iterator(const poplar::OptionFlags::iterator &)__CXXConstructor +{ using namespace poplar; +JLOptionFlagsiterator.constructor(); +} +// poplar::OptionFlags::OptionFlags(const poplar::OptionFlags &)__CXXConstructor +{ using namespace poplar; +JLOptionFlags.constructor(); +} +// poplar::OptionFlags::set(std::string, std::string)__CXXMethod +{ using namespace poplar; +JLOptionFlags.method("OptionFlagsSet", [](poplar::OptionFlags& cl, std::string a, std::string b) {return cl.set(a, b);}); +} +// poplar::OptionFlags::at(std::string)__CXXMethod +{ using namespace poplar; +JLOptionFlags.method("OptionFlagsAt", [](poplar::OptionFlags& cl, std::string a) {return cl.at(a);}); +} +// poplar::OptionFlags::clear()__CXXMethod +{ using namespace poplar; +JLOptionFlags.method("OptionFlagsClear", [](poplar::OptionFlags& cl) {return cl.clear();}); +} +// poplar::OptionFlags::begin()__CXXMethod +{ using namespace poplar; +JLOptionFlags.method("OptionFlagsBegin", [](poplar::OptionFlags& cl) {return cl.begin();}); +} +// poplar::OptionFlags::end()__CXXMethod +{ using namespace poplar; +JLOptionFlags.method("OptionFlagsEnd", [](poplar::OptionFlags& cl) {return cl.end();}); +} +// poplar::getAsProfileValue(const poplar::OptionFlags &)__FunctionDecl +{ using namespace poplar; +mod.method("PoplarGetAsProfileValue", [](const poplar::OptionFlags & a) {return poplar::getAsProfileValue(a);} ); } +// poplar::readJSON(std::string, poplar::OptionFlags &)__FunctionDecl +{ using namespace poplar; +mod.method("PoplarReadJSON", [](std::string a, poplar::OptionFlags & b) {return poplar::readJSON(a, b);} ); } +// poplar::readJSONFromEnv(std::string, poplar::OptionFlags &)__FunctionDecl +{ using namespace poplar; +mod.method("PoplarReadJSONFromEnv", [](std::string a, poplar::OptionFlags & b) {return poplar::readJSONFromEnv(a, b);} ); } +// poplar::GlobalExchangeFlow::GlobalExchangeFlow(unsigned int, unsigned int)__CXXConstructor +{ using namespace poplar; +JLGlobalExchangeFlow.constructor(); +} +// poplar::GlobalExchangeConstraint::GlobalExchangeConstraint(double, ArrayRef)__CXXConstructor +{ using namespace poplar; +JLGlobalExchangeConstraint.constructor>(); +} +// poplar::IpuLinkConfiguration::Default__EnumConstantDecl +mod.set_const("PoplarIpuLinkConfigurationPoplarDefault", poplar::IpuLinkConfiguration::Default); +// poplar::IpuLinkConfiguration::SlidingWindow__EnumConstantDecl +mod.set_const("PoplarIpuLinkConfigurationPoplarSlidingWindow", poplar::IpuLinkConfiguration::SlidingWindow); +// poplar::IpuLinkConfiguration::BarleyTwist__EnumConstantDecl +mod.set_const("PoplarIpuLinkConfigurationPoplarBarleyTwist", poplar::IpuLinkConfiguration::BarleyTwist); +// poplar::IpuLinkTopology::Mesh__EnumConstantDecl +mod.set_const("PoplarIpuLinkTopologyPoplarMesh", poplar::IpuLinkTopology::Mesh); +// poplar::IpuLinkTopology::Torus__EnumConstantDecl +mod.set_const("PoplarIpuLinkTopologyPoplarTorus", poplar::IpuLinkTopology::Torus); +// poplar::TargetType::IPU__EnumConstantDecl +mod.set_const("PoplarTargetTypePoplarIPU", poplar::TargetType::IPU); +// poplar::TargetType::IPU_MODEL__EnumConstantDecl +mod.set_const("PoplarTargetTypePoplarIPU_MODEL", poplar::TargetType::IPU_MODEL); +// poplar::TargetType::CPU__EnumConstantDecl +mod.set_const("PoplarTargetTypePoplarCPU", poplar::TargetType::CPU); +// poplar::Type::Type(const poplar::Type &)__CXXConstructor +{ using namespace poplar; +JLType.constructor(); +} +// poplar::Type::toString()__CXXMethod +{ using namespace poplar; +JLType.method("TypeToString", [](poplar::Type& cl) {return cl.toString();}); +} +// poplar::Type::hash()__CXXMethod +{ using namespace poplar; +JLType.method("TypeHash", [](poplar::Type& cl) {return cl.hash();}); +} +// poplar::Type::isFloatingPoint()__CXXMethod +{ using namespace poplar; +JLType.method("TypeIsFloatingPoint", [](poplar::Type& cl) {return cl.isFloatingPoint();}); +} +// poplar::Type::requiresMetadata()__CXXMethod +{ using namespace poplar; +JLType.method("TypeRequiresMetadata", [](poplar::Type& cl) {return cl.requiresMetadata();}); +} +// poplar::Target::Target(const poplar::Target &)__CXXConstructor +{ using namespace poplar; +JLTarget.constructor(); +} +// poplar::Target::hash()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetHash", [](poplar::Target& cl) {return cl.hash();}); +} +// poplar::Target::getTargetType()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetTargetType", [](poplar::Target& cl) {return cl.getTargetType();}); +} +// poplar::Target::getTargetSystemString()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetTargetSystemString", [](poplar::Target& cl) {return cl.getTargetSystemString();}); +} +// poplar::Target::getTargetArchString()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetTargetArchString", [](poplar::Target& cl) {return cl.getTargetArchString();}); +} +// poplar::Target::getNumIPUs()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetNumIPUs", [](poplar::Target& cl) {return cl.getNumIPUs();}); +} +// poplar::Target::getTilesPerIPU()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetTilesPerIPU", [](poplar::Target& cl) {return cl.getTilesPerIPU();}); +} +// poplar::Target::getNumWorkerContexts()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetNumWorkerContexts", [](poplar::Target& cl) {return cl.getNumWorkerContexts();}); +} +// poplar::Target::getBytesPerTile()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetBytesPerTile", [](poplar::Target& cl) {return cl.getBytesPerTile();}); +} +// poplar::Target::getExchangeBytesPerCycle()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetExchangeBytesPerCycle", [](poplar::Target& cl) {return cl.getExchangeBytesPerCycle();}); +} +// poplar::Target::getMemcpyBytesPerCycle()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetMemcpyBytesPerCycle", [](poplar::Target& cl) {return cl.getMemcpyBytesPerCycle();}); +} +// poplar::Target::getMinIPUSyncDelay()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetMinIPUSyncDelay", [](poplar::Target& cl) {return cl.getMinIPUSyncDelay();}); +} +// poplar::Target::getGlobalSyncCycles()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetGlobalSyncCycles", [](poplar::Target& cl) {return cl.getGlobalSyncCycles();}); +} +// poplar::Target::getMemoryElementOffsets()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetMemoryElementOffsets", [](poplar::Target& cl) {return cl.getMemoryElementOffsets();}); +} +// poplar::Target::getInterleavedMemoryElementIndex()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetInterleavedMemoryElementIndex", [](poplar::Target& cl) {return cl.getInterleavedMemoryElementIndex();}); +} +// poplar::Target::getNumStrideBits()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetNumStrideBits", [](poplar::Target& cl) {return cl.getNumStrideBits();}); +} +// poplar::Target::getDataPathWidth()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetDataPathWidth", [](poplar::Target& cl) {return cl.getDataPathWidth();}); +} +// poplar::Target::getFp8ConvUnitMaxPipelineDepth()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetFp8ConvUnitMaxPipelineDepth", [](poplar::Target& cl) {return cl.getFp8ConvUnitMaxPipelineDepth();}); +} +// poplar::Target::getFp16ConvUnitMaxPipelineDepth()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetFp16ConvUnitMaxPipelineDepth", [](poplar::Target& cl) {return cl.getFp16ConvUnitMaxPipelineDepth();}); +} +// poplar::Target::getFp32ConvUnitMaxPipelineDepth()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetFp32ConvUnitMaxPipelineDepth", [](poplar::Target& cl) {return cl.getFp32ConvUnitMaxPipelineDepth();}); +} +// poplar::Target::getFp8ConvUnitInputLoadElemsPerCycle()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetFp8ConvUnitInputLoadElemsPerCycle", [](poplar::Target& cl) {return cl.getFp8ConvUnitInputLoadElemsPerCycle();}); +} +// poplar::Target::getFp16ConvUnitInputLoadElemsPerCycle()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetFp16ConvUnitInputLoadElemsPerCycle", [](poplar::Target& cl) {return cl.getFp16ConvUnitInputLoadElemsPerCycle();}); +} +// poplar::Target::getFp32ConvUnitInputLoadElemsPerCycle()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetFp32ConvUnitInputLoadElemsPerCycle", [](poplar::Target& cl) {return cl.getFp32ConvUnitInputLoadElemsPerCycle();}); +} +// poplar::Target::getFp16InFp16OutConvUnitsPerTile()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetFp16InFp16OutConvUnitsPerTile", [](poplar::Target& cl) {return cl.getFp16InFp16OutConvUnitsPerTile();}); +} +// poplar::Target::getFp16InFp32OutConvUnitsPerTile()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetFp16InFp32OutConvUnitsPerTile", [](poplar::Target& cl) {return cl.getFp16InFp32OutConvUnitsPerTile();}); +} +// poplar::Target::getFp32InFp32OutConvUnitsPerTile()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetFp32InFp32OutConvUnitsPerTile", [](poplar::Target& cl) {return cl.getFp32InFp32OutConvUnitsPerTile();}); +} +// poplar::Target::getFp8InFp16OutConvUnitsPerTile()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetFp8InFp16OutConvUnitsPerTile", [](poplar::Target& cl) {return cl.getFp8InFp16OutConvUnitsPerTile();}); +} +// poplar::Target::getConvUnitCoeffLoadBytesPerCycle()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetConvUnitCoeffLoadBytesPerCycle", [](poplar::Target& cl) {return cl.getConvUnitCoeffLoadBytesPerCycle();}); +} +// poplar::Target::getRptCountMax()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetRptCountMax", [](poplar::Target& cl) {return cl.getRptCountMax();}); +} +// poplar::Target::supportsExchangeBusSharing()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetSupportsExchangeBusSharing", [](poplar::Target& cl) {return cl.supportsExchangeBusSharing();}); +} +// poplar::Target::getTilesPerSharedExchangeBus()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetTilesPerSharedExchangeBus", [](poplar::Target& cl) {return cl.getTilesPerSharedExchangeBus();}); +} +// poplar::Target::getNumTiles()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetNumTiles", [](poplar::Target& cl) {return cl.getNumTiles();}); +} +// poplar::Target::getMemoryBytes()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetMemoryBytes", [](poplar::Target& cl) {return cl.getMemoryBytes();}); +} +// poplar::Target::getFloatVectorWidth()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetFloatVectorWidth", [](poplar::Target& cl) {return cl.getFloatVectorWidth();}); +} +// poplar::Target::getHalfVectorWidth()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetHalfVectorWidth", [](poplar::Target& cl) {return cl.getHalfVectorWidth();}); +} +// poplar::Target::getQuarterVectorWidth()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetQuarterVectorWidth", [](poplar::Target& cl) {return cl.getQuarterVectorWidth();}); +} +// poplar::Target::getVectorWidth(const poplar::Type &)__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetVectorWidth", [](poplar::Target& cl, const poplar::Type & a) {return cl.getVectorWidth(a);}); +} +// poplar::Target::getWeightsPerConvUnit(const poplar::Type &)__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetWeightsPerConvUnit", [](poplar::Target& cl, const poplar::Type & a) {return cl.getWeightsPerConvUnit(a);}); +} +// poplar::Target::getConvUnitInputLoadElemsPerCycle(const poplar::Type &)__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetConvUnitInputLoadElemsPerCycle", [](poplar::Target& cl, const poplar::Type & a) {return cl.getConvUnitInputLoadElemsPerCycle(a);}); +} +// poplar::Target::getConvUnitMaxPipelineDepth(const poplar::Type &)__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetConvUnitMaxPipelineDepth", [](poplar::Target& cl, const poplar::Type & a) {return cl.getConvUnitMaxPipelineDepth(a);}); +} +// poplar::Target::getNumConvUnits(const poplar::Type &, const poplar::Type &)__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetNumConvUnits", [](poplar::Target& cl, const poplar::Type & a, const poplar::Type & b) {return cl.getNumConvUnits(a, b);}); +} +// poplar::Target::getMaxIPUSyncDelay()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetMaxIPUSyncDelay", [](poplar::Target& cl) {return cl.getMaxIPUSyncDelay();}); +} +// poplar::Target::getTileClockFrequency()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetTileClockFrequency", [](poplar::Target& cl) {return cl.getTileClockFrequency();}); +} +// poplar::Target::getNumTilesPerXBContext()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetNumTilesPerXBContext", [](poplar::Target& cl) {return cl.getNumTilesPerXBContext();}); +} +// poplar::Target::getNumContextsPerXB()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetNumContextsPerXB", [](poplar::Target& cl) {return cl.getNumContextsPerXB();}); +} +// poplar::Target::getTileHostExchangeXB(unsigned int)__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetTileHostExchangeXB", [](poplar::Target& cl, unsigned int a) {return cl.getTileHostExchangeXB(a);}); +} +// poplar::Target::getTileHostExchangeContext(unsigned int)__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetTileHostExchangeContext", [](poplar::Target& cl, unsigned int a) {return cl.getTileHostExchangeContext(a);}); +} +// poplar::Target::getTileHostExchangeContextPosition(unsigned int)__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetTileHostExchangeContextPosition", [](poplar::Target& cl, unsigned int a) {return cl.getTileHostExchangeContextPosition(a);}); +} +// poplar::Target::getTypeSize(const poplar::Type &)__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetTypeSize", [](poplar::Target& cl, const poplar::Type & a) {return cl.getTypeSize(a);}); +} +// poplar::Target::getAtomicStoreGranularity()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetAtomicStoreGranularity", [](poplar::Target& cl) {return cl.getAtomicStoreGranularity();}); +} +// poplar::Target::makeFpIctlValue(bool, bool, bool, bool, bool)__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetMakeFpIctlValue", [](poplar::Target& cl, bool a, bool b, bool c, bool d, bool e) {return cl.makeFpIctlValue(a, b, c, d, e);}); +} +// poplar::Target::getFpIctlRegIndex()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetFpIctlRegIndex", [](poplar::Target& cl) {return cl.getFpIctlRegIndex();}); +} +// poplar::Target::getDbgDataRegIndex()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetDbgDataRegIndex", [](poplar::Target& cl) {return cl.getDbgDataRegIndex();}); +} +// poplar::Target::getIpuLinkConfiguration()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetIpuLinkConfiguration", [](poplar::Target& cl) {return cl.getIpuLinkConfiguration();}); +} +// poplar::Target::getIpuLinkTopology()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetIpuLinkTopology", [](poplar::Target& cl) {return cl.getIpuLinkTopology();}); +} +// poplar::Target::getIpuLinkDomainSize()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetIpuLinkDomainSize", [](poplar::Target& cl) {return cl.getIpuLinkDomainSize();}); +} +// poplar::Target::getInstanceSize()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetInstanceSize", [](poplar::Target& cl) {return cl.getInstanceSize();}); +} +// poplar::Target::getGatewayMode()__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetGatewayMode", [](poplar::Target& cl) {return cl.getGatewayMode();}); +} +// poplar::Target::createVirtualTarget(unsigned int, unsigned int)__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetCreateVirtualTarget", [](poplar::Target& cl, unsigned int a, unsigned int b) {return cl.createVirtualTarget(a, b);}); +} +// poplar::Target::createCPUTarget(bool, unsigned int)__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetCreateCPUTarget", [](poplar::Target& cl) {return cl.createCPUTarget();}); +JLTarget.method("TargetCreateCPUTarget", [](poplar::Target& cl, bool a) {return cl.createCPUTarget(a);}); +JLTarget.method("TargetCreateCPUTarget", [](poplar::Target& cl, bool a, unsigned int b) {return cl.createCPUTarget(a, b);}); +} +// poplar::Target::createIPUTarget(std::string, const poplar::OptionFlags &)__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetCreateIPUTarget", [](poplar::Target& cl, std::string a) {return cl.createIPUTarget(a);}); +JLTarget.method("TargetCreateIPUTarget", [](poplar::Target& cl, std::string a, const poplar::OptionFlags & b) {return cl.createIPUTarget(a, b);}); +} +// poplar::Target::createIPUTarget(unsigned int, std::string, const poplar::OptionFlags &)__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetCreateIPUTarget", [](poplar::Target& cl, unsigned int a, std::string b) {return cl.createIPUTarget(a, b);}); +JLTarget.method("TargetCreateIPUTarget", [](poplar::Target& cl, unsigned int a, std::string b, const poplar::OptionFlags & c) {return cl.createIPUTarget(a, b, c);}); +} +// poplar::Target::createIPUTarget(unsigned int, unsigned int, std::string, const poplar::OptionFlags &)__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetCreateIPUTarget", [](poplar::Target& cl, unsigned int a, unsigned int b, std::string c) {return cl.createIPUTarget(a, b, c);}); +JLTarget.method("TargetCreateIPUTarget", [](poplar::Target& cl, unsigned int a, unsigned int b, std::string c, const poplar::OptionFlags & d) {return cl.createIPUTarget(a, b, c, d);}); +} +// poplar::copyDeviceHalfToFloat(const poplar::Target &, const void *, float *, std::size_t)__FunctionDecl +{ using namespace poplar; +mod.method("PoplarCopyDeviceHalfToFloat", [](const poplar::Target & a, const void * b, float * c, std::size_t d) {return poplar::copyDeviceHalfToFloat(a, b, c, d);} ); } +// poplar::copyFloatToDeviceHalf(const poplar::Target &, const float *, void *, std::size_t)__FunctionDecl +{ using namespace poplar; +mod.method("PoplarCopyFloatToDeviceHalf", [](const poplar::Target & a, const float * b, void * c, std::size_t d) {return poplar::copyFloatToDeviceHalf(a, b, c, d);} ); } +// poplar::copyDeviceHalfToDouble(const poplar::Target &, const void *, double *, std::size_t)__FunctionDecl +{ using namespace poplar; +mod.method("PoplarCopyDeviceHalfToDouble", [](const poplar::Target & a, const void * b, double * c, std::size_t d) {return poplar::copyDeviceHalfToDouble(a, b, c, d);} ); } +// poplar::copyDoubleToDeviceHalf(const poplar::Target &, const double *, void *, std::size_t)__FunctionDecl +{ using namespace poplar; +mod.method("PoplarCopyDoubleToDeviceHalf", [](const poplar::Target & a, const double * b, void * c, std::size_t d) {return poplar::copyDoubleToDeviceHalf(a, b, c, d);} ); } +// poplar::Device::getId()__CXXMethod +{ using namespace poplar; +JLDevice.method("DeviceGetId", [](poplar::Device& cl) {return cl.getId();}); +} +// poplar::Device::getTarget()__CXXMethod +{ using namespace poplar; +JLDevice.method("DeviceGetTarget", [](poplar::Device& cl) {return cl.getTarget();}); +} +// poplar::Device::attach()__CXXMethod +{ using namespace poplar; +JLDevice.method("DeviceAttach", [](poplar::Device& cl) {return cl.attach();}); +} +// poplar::Device::detach()__CXXMethod +{ using namespace poplar; +JLDevice.method("DeviceDetach", [](poplar::Device& cl) {return cl.detach();}); +} +// poplar::Device::getDriverVersion(unsigned int &, unsigned int &, unsigned int &)__CXXMethod +{ using namespace poplar; +JLDevice.method("DeviceGetDriverVersion", [](poplar::Device& cl, unsigned int & a, unsigned int & b, unsigned int & c) {return cl.getDriverVersion(a, b, c);}); +} +// poplar::Device::supportsRemoteBuffers()__CXXMethod +{ using namespace poplar; +JLDevice.method("DeviceSupportsRemoteBuffers", [](poplar::Device& cl) {return cl.supportsRemoteBuffers();}); +} +// poplar::Device::hasGateway()__CXXMethod +{ using namespace poplar; +JLDevice.method("DeviceHasGateway", [](poplar::Device& cl) {return cl.hasGateway();}); +} +// poplar::Device::getAttributes()__CXXMethod +{ using namespace poplar; +JLDevice.method("DeviceGetAttributes", [](poplar::Device& cl) {return cl.getAttributes();}); +} +// poplar::Device::getNumaTopology()__CXXMethod +{ using namespace poplar; +JLDevice.method("DeviceGetNumaTopology", [](poplar::Device& cl) {return cl.getNumaTopology();}); +} +// poplar::Device::getNumaNodesUsedForIPUs()__CXXMethod +{ using namespace poplar; +JLDevice.method("DeviceGetNumaNodesUsedForIPUs", [](poplar::Device& cl) {return cl.getNumaNodesUsedForIPUs();}); +} +// poplar::Device::getDriverIDs()__CXXMethod +{ using namespace poplar; +JLDevice.method("DeviceGetDriverIDs", [](poplar::Device& cl) {return cl.getDriverIDs();}); +} +// poplar::Device::reset()__CXXMethod +{ using namespace poplar; +JLDevice.method("DeviceReset", [](poplar::Device& cl) {return cl.reset();}); +} +// poplar::Device::createVirtualDevice(unsigned int)__CXXMethod +{ using namespace poplar; +JLDevice.method("DeviceCreateVirtualDevice", [](poplar::Device& cl, unsigned int a) {return cl.createVirtualDevice(a);}); +} +// poplar::Device::createCPUDevice(unsigned int)__CXXMethod +{ using namespace poplar; +JLDevice.method("DeviceCreateCPUDevice", [](poplar::Device& cl) {return cl.createCPUDevice();}); +JLDevice.method("DeviceCreateCPUDevice", [](poplar::Device& cl, unsigned int a) {return cl.createCPUDevice(a);}); +} +// poplar::Device::createSimulatorDevice(const poplar::Target &, const poplar::OptionFlags &)__CXXMethod +{ using namespace poplar; +JLDevice.method("DeviceCreateSimulatorDevice", [](poplar::Device& cl, const poplar::Target & a) {return cl.createSimulatorDevice(a);}); +JLDevice.method("DeviceCreateSimulatorDevice", [](poplar::Device& cl, const poplar::Target & a, const poplar::OptionFlags & b) {return cl.createSimulatorDevice(a, b);}); +} +// poplar::DeviceManager::DeviceManager(const poplar::DeviceManager &)__CXXConstructor +{ using namespace poplar; +JLDeviceManager.constructor(); +} +// poplar::DeviceManager::getNumDevices()__CXXMethod +{ using namespace poplar; +JLDeviceManager.method("DeviceManagerGetNumDevices", [](poplar::DeviceManager& cl) {return cl.getNumDevices();}); +} +// poplar::DeviceManager::getDevice(unsigned int, const poplar::OptionFlags &)__CXXMethod +{ using namespace poplar; +JLDeviceManager.method("DeviceManagerGetDevice", [](poplar::DeviceManager& cl, unsigned int a) {return cl.getDevice(a);}); +JLDeviceManager.method("DeviceManagerGetDevice", [](poplar::DeviceManager& cl, unsigned int a, const poplar::OptionFlags & b) {return cl.getDevice(a, b);}); +} +// poplar::DeviceManager::getChildDeviceIds(unsigned int, unsigned int)__CXXMethod +{ using namespace poplar; +JLDeviceManager.method("DeviceManagerGetChildDeviceIds", [](poplar::DeviceManager& cl, unsigned int a) {return cl.getChildDeviceIds(a);}); +JLDeviceManager.method("DeviceManagerGetChildDeviceIds", [](poplar::DeviceManager& cl, unsigned int a, unsigned int b) {return cl.getChildDeviceIds(a, b);}); +} +// poplar::DeviceManager::createDeviceManager()__CXXMethod +{ using namespace poplar; +JLDeviceManager.method("DeviceManagerCreateDeviceManager", [](poplar::DeviceManager& cl) {return cl.createDeviceManager();}); +} +// poplar::CodeletFileType::PreprocessedAsmSource__EnumConstantDecl +mod.set_const("PoplarCodeletFileTypePoplarPreprocessedAsmSource", poplar::CodeletFileType::PreprocessedAsmSource); +// poplar::CodeletFileType::AsmSource__EnumConstantDecl +mod.set_const("PoplarCodeletFileTypePoplarAsmSource", poplar::CodeletFileType::AsmSource); +// poplar::CodeletFileType::CSource__EnumConstantDecl +mod.set_const("PoplarCodeletFileTypePoplarCSource", poplar::CodeletFileType::CSource); +// poplar::CodeletFileType::CppSource__EnumConstantDecl +mod.set_const("PoplarCodeletFileTypePoplarCppSource", poplar::CodeletFileType::CppSource); +// poplar::CodeletFileType::IrSource__EnumConstantDecl +mod.set_const("PoplarCodeletFileTypePoplarIrSource", poplar::CodeletFileType::IrSource); +// poplar::CodeletFileType::Object__EnumConstantDecl +mod.set_const("PoplarCodeletFileTypePoplarObject", poplar::CodeletFileType::Object); +// poplar::CodeletFileType::Auto__EnumConstantDecl +mod.set_const("PoplarCodeletFileTypePoplarAuto", poplar::CodeletFileType::Auto); +// poplar::getCodeletFileType(const char *)__FunctionDecl +{ using namespace poplar; +mod.method("PoplarGetCodeletFileType", [](const char * a) {return poplar::getCodeletFileType(a);} ); } +// poplar::getExtensionFromFileType(poplar::CodeletFileType)__FunctionDecl +{ using namespace poplar; +mod.method("PoplarGetExtensionFromFileType", [](poplar::CodeletFileType a) {return poplar::getExtensionFromFileType(a);} ); } +// poplar::getLanguageOption(poplar::CodeletFileType)__FunctionDecl +{ using namespace poplar; +mod.method("PoplarGetLanguageOption", [](poplar::CodeletFileType a) {return poplar::getLanguageOption(a);} ); } +// poplar::DataStreamType::HostToDeviceFIFO__EnumConstantDecl +mod.set_const("PoplarDataStreamTypePoplarHostToDeviceFIFO", poplar::DataStreamType::HostToDeviceFIFO); +// poplar::DataStreamType::DeviceToHostFIFO__EnumConstantDecl +mod.set_const("PoplarDataStreamTypePoplarDeviceToHostFIFO", poplar::DataStreamType::DeviceToHostFIFO); +// poplar::DataStreamType::HostToDeviceBuffer__EnumConstantDecl +mod.set_const("PoplarDataStreamTypePoplarHostToDeviceBuffer", poplar::DataStreamType::HostToDeviceBuffer); +// poplar::DataStreamType::DeviceToHostBuffer__EnumConstantDecl +mod.set_const("PoplarDataStreamTypePoplarDeviceToHostBuffer", poplar::DataStreamType::DeviceToHostBuffer); +// poplar::isDeviceToHost(poplar::DataStreamType)__FunctionDecl +{ using namespace poplar; +mod.method("PoplarIsDeviceToHost", [](poplar::DataStreamType a) {return poplar::isDeviceToHost(a);} ); } +// poplar::isHostToDevice(poplar::DataStreamType)__FunctionDecl +{ using namespace poplar; +mod.method("PoplarIsHostToDevice", [](poplar::DataStreamType a) {return poplar::isHostToDevice(a);} ); } +// poplar::isRemoteBuffer(poplar::DataStreamType)__FunctionDecl +{ using namespace poplar; +mod.method("PoplarIsRemoteBuffer", [](poplar::DataStreamType a) {return poplar::isRemoteBuffer(a);} ); } +// poplar::ReplicatedStreamMode::REPLICATE__EnumConstantDecl +mod.set_const("PoplarReplicatedStreamModePoplarREPLICATE", poplar::ReplicatedStreamMode::REPLICATE); +// poplar::ReplicatedStreamMode::BROADCAST__EnumConstantDecl +mod.set_const("PoplarReplicatedStreamModePoplarBROADCAST", poplar::ReplicatedStreamMode::BROADCAST); +// poplar::DataStream::DataStream(const poplar::DataStream &)__CXXConstructor +{ using namespace poplar; +JLDataStream.constructor(); +} +// poplar::DataStream::handle()__CXXMethod +{ using namespace poplar; +JLDataStream.method("DataStreamHandle", [](poplar::DataStream& cl) {return cl.handle();}); +} +// poplar::DataStream::numElements()__CXXMethod +{ using namespace poplar; +JLDataStream.method("DataStreamNumElements", [](poplar::DataStream& cl) {return cl.numElements();}); +} +// poplar::DataStream::replicationFactor()__CXXMethod +{ using namespace poplar; +JLDataStream.method("DataStreamReplicationFactor", [](poplar::DataStream& cl) {return cl.replicationFactor();}); +} +// poplar::DataStream::replicatedMode()__CXXMethod +{ using namespace poplar; +JLDataStream.method("DataStreamReplicatedMode", [](poplar::DataStream& cl) {return cl.replicatedMode();}); +} +// poplar::DataStream::type()__CXXMethod +{ using namespace poplar; +JLDataStream.method("DataStreamType", [](poplar::DataStream& cl) {return cl.type();}); +} +// poplar::DataStream::elementType()__CXXMethod +{ using namespace poplar; +JLDataStream.method("DataStreamElementType", [](poplar::DataStream& cl) {return cl.elementType();}); +} +// poplar::RemoteBuffer::RemoteBuffer(const poplar::RemoteBuffer &)__CXXConstructor +{ using namespace poplar; +JLRemoteBuffer.constructor(); +} +// poplar::RemoteBuffer::handle()__CXXMethod +{ using namespace poplar; +JLRemoteBuffer.method("RemoteBufferHandle", [](poplar::RemoteBuffer& cl) {return cl.handle();}); +} +// poplar::RemoteBuffer::getIpuToHostStream()__CXXMethod +{ using namespace poplar; +JLRemoteBuffer.method("RemoteBufferGetIpuToHostStream", [](poplar::RemoteBuffer& cl) {return cl.getIpuToHostStream();}); +} +// poplar::RemoteBuffer::getHostToIpuStream()__CXXMethod +{ using namespace poplar; +JLRemoteBuffer.method("RemoteBufferGetHostToIpuStream", [](poplar::RemoteBuffer& cl) {return cl.getHostToIpuStream();}); +} +// poplar::RemoteBuffer::numElements()__CXXMethod +{ using namespace poplar; +JLRemoteBuffer.method("RemoteBufferNumElements", [](poplar::RemoteBuffer& cl) {return cl.numElements();}); +} +// poplar::RemoteBuffer::getRepeats()__CXXMethod +{ using namespace poplar; +JLRemoteBuffer.method("RemoteBufferGetRepeats", [](poplar::RemoteBuffer& cl) {return cl.getRepeats();}); +} +// poplar::RemoteBuffer::elementType()__CXXMethod +{ using namespace poplar; +JLRemoteBuffer.method("RemoteBufferElementType", [](poplar::RemoteBuffer& cl) {return cl.elementType();}); +} +// poplar::RemoteBuffer::isRearrangeOnHost()__CXXMethod +{ using namespace poplar; +JLRemoteBuffer.method("RemoteBufferIsRearrangeOnHost", [](poplar::RemoteBuffer& cl) {return cl.isRearrangeOnHost();}); +} +// poplar::RemoteBuffer::isOptimisedForMemory()__CXXMethod +{ using namespace poplar; +JLRemoteBuffer.method("RemoteBufferIsOptimisedForMemory", [](poplar::RemoteBuffer& cl) {return cl.isOptimisedForMemory();}); +} +// poplar::ProfileValue::Type::BOOL___EnumConstantDecl +mod.set_const("ProfileValueTypeProfileValueBOOL_", poplar::ProfileValue::Type::BOOL_); +// poplar::ProfileValue::Type::STRING__EnumConstantDecl +mod.set_const("ProfileValueTypeProfileValueSTRING", poplar::ProfileValue::Type::STRING); +// poplar::ProfileValue::Type::NUMBER__EnumConstantDecl +mod.set_const("ProfileValueTypeProfileValueNUMBER", poplar::ProfileValue::Type::NUMBER); +// poplar::ProfileValue::Type::VECTOR__EnumConstantDecl +mod.set_const("ProfileValueTypeProfileValueVECTOR", poplar::ProfileValue::Type::VECTOR); +// poplar::ProfileValue::Type::MAP__EnumConstantDecl +mod.set_const("ProfileValueTypeProfileValueMAP", poplar::ProfileValue::Type::MAP); +// poplar::ProfileValue::type()__CXXMethod +{ using namespace poplar; +JLProfileValue.method("ProfileValueType", [](poplar::ProfileValue& cl) {return cl.type();}); +} +// poplar::ProfileValue::asString()__CXXMethod +{ using namespace poplar; +JLProfileValue.method("ProfileValueAsString", [](poplar::ProfileValue& cl) {return cl.asString();}); +} +// poplar::ProfileValue::asBool()__CXXMethod +{ using namespace poplar; +JLProfileValue.method("ProfileValueAsBool", [](poplar::ProfileValue& cl) {return cl.asBool();}); +} +// poplar::ProfileValue::asInt()__CXXMethod +{ using namespace poplar; +JLProfileValue.method("ProfileValueAsInt", [](poplar::ProfileValue& cl) {return cl.asInt();}); +} +// poplar::ProfileValue::asUint()__CXXMethod +{ using namespace poplar; +JLProfileValue.method("ProfileValueAsUint", [](poplar::ProfileValue& cl) {return cl.asUint();}); +} +// poplar::ProfileValue::asDouble()__CXXMethod +{ using namespace poplar; +JLProfileValue.method("ProfileValueAsDouble", [](poplar::ProfileValue& cl) {return cl.asDouble();}); +} +// poplar::ProfileValue::getOrNull(std::string)__CXXMethod +{ using namespace poplar; +JLProfileValue.method("ProfileValueGetOrNull", [](poplar::ProfileValue& cl, std::string a) {return cl.getOrNull(a);}); +} +// poplar::ProfileValue::asMap()__CXXMethod +{ using namespace poplar; +JLProfileValue.method("ProfileValueAsMap", [](poplar::ProfileValue& cl) {return cl.asMap();}); +} +// poplar::ProfileValue::asVector()__CXXMethod +{ using namespace poplar; +JLProfileValue.method("ProfileValueAsVector", [](poplar::ProfileValue& cl) {return cl.asVector();}); +} +// poplar::ProfileValue::toUintVector()__CXXMethod +{ using namespace poplar; +JLProfileValue.method("ProfileValueToUintVector", [](poplar::ProfileValue& cl) {return cl.toUintVector();}); +} +// poplar::ProfileValue::size()__CXXMethod +{ using namespace poplar; +JLProfileValue.method("ProfileValueSize", [](poplar::ProfileValue& cl) {return cl.size();}); +} +// poplar::ProfileValue::sumDouble()__CXXMethod +{ using namespace poplar; +JLProfileValue.method("ProfileValueSumDouble", [](poplar::ProfileValue& cl) {return cl.sumDouble();}); +} +// poplar::ProfileValue::sumInt()__CXXMethod +{ using namespace poplar; +JLProfileValue.method("ProfileValueSumInt", [](poplar::ProfileValue& cl) {return cl.sumInt();}); +} +// poplar::ProfileValue::sumUint()__CXXMethod +{ using namespace poplar; +JLProfileValue.method("ProfileValueSumUint", [](poplar::ProfileValue& cl) {return cl.sumUint();}); +} +// poplar::ProfileValue::sum2DInt()__CXXMethod +{ using namespace poplar; +JLProfileValue.method("ProfileValueSum2DInt", [](poplar::ProfileValue& cl) {return cl.sum2DInt();}); +} +// poplar::ProfileValue::sum2DUint()__CXXMethod +{ using namespace poplar; +JLProfileValue.method("ProfileValueSum2DUint", [](poplar::ProfileValue& cl) {return cl.sum2DUint();}); +} +// poplar::ProfileValue::ProfileValue(poplar::ProfileValue::String)__CXXConstructor +{ using namespace poplar; +JLProfileValue.constructor(); +} +// poplar::ProfileValue::ProfileValue(poplar::ProfileValue::Vector)__CXXConstructor +{ using namespace poplar; +JLProfileValue.constructor(); +} +// poplar::ProfileValue::ProfileValue(poplar::ProfileValue::Map)__CXXConstructor +{ using namespace poplar; +JLProfileValue.constructor(); +} +// poplar::ProfileValue::ProfileValue(poplar::ProfileValue::Number)__CXXConstructor +{ using namespace poplar; +JLProfileValue.constructor(); +} +// poplar::ProfileValue::ProfileValue(poplar::ProfileValue::Boolean)__CXXConstructor +{ using namespace poplar; +JLProfileValue.constructor(); +} +// poplar::ProfileValue::ProfileValue(const char *)__CXXConstructor +{ using namespace poplar; +JLProfileValue.constructor(); +} +// poplar::ProfileValue::ProfileValue(const poplar::ProfileValue &)__CXXConstructor +{ using namespace poplar; +JLProfileValue.constructor(); +} +// poplar::SerializationFormat::Binary__EnumConstantDecl +mod.set_const("PoplarSerializationFormatPoplarBinary", poplar::SerializationFormat::Binary); +// poplar::SerializationFormat::JSON__EnumConstantDecl +mod.set_const("PoplarSerializationFormatPoplarJSON", poplar::SerializationFormat::JSON); +// poplar::SourceLocation::SourceLocation(const char *, const char *, unsigned int)__CXXConstructor +{ using namespace poplar; +JLSourceLocation.constructor(); +} +// poplar::SourceLocation::getFunctionName()__CXXMethod +{ using namespace poplar; +JLSourceLocation.method("SourceLocationGetFunctionName", [](poplar::SourceLocation& cl) {return cl.getFunctionName();}); +} +// poplar::SourceLocation::getFileName()__CXXMethod +{ using namespace poplar; +JLSourceLocation.method("SourceLocationGetFileName", [](poplar::SourceLocation& cl) {return cl.getFileName();}); +} +// poplar::SourceLocation::getLineNumber()__CXXMethod +{ using namespace poplar; +JLSourceLocation.method("SourceLocationGetLineNumber", [](poplar::SourceLocation& cl) {return cl.getLineNumber();}); +} +// poplar::SourceLocation::isValid()__CXXMethod +{ using namespace poplar; +JLSourceLocation.method("SourceLocationIsValid", [](poplar::SourceLocation& cl) {return cl.isValid();}); +} +// poplar::SourceLocation::Current(const char *, const char *, unsigned int)__CXXMethod +{ using namespace poplar; +JLSourceLocation.method("SourceLocationCurrent", [](poplar::SourceLocation& cl) {return cl.Current();}); +JLSourceLocation.method("SourceLocationCurrent", [](poplar::SourceLocation& cl, const char * a) {return cl.Current(a);}); +JLSourceLocation.method("SourceLocationCurrent", [](poplar::SourceLocation& cl, const char * a, const char * b) {return cl.Current(a, b);}); +JLSourceLocation.method("SourceLocationCurrent", [](poplar::SourceLocation& cl, const char * a, const char * b, unsigned int c) {return cl.Current(a, b, c);}); +} +// poplar::DebugSerializationFormat::JSON__EnumConstantDecl +mod.set_const("PoplarDebugSerializationFormatPoplarJSON", poplar::DebugSerializationFormat::JSON); +// poplar::DebugSerializationFormat::CBOR__EnumConstantDecl +mod.set_const("PoplarDebugSerializationFormatPoplarCBOR", poplar::DebugSerializationFormat::CBOR); +// poplar::DebugInfo::DebugInfo(const poplar::DebugContext &, std::string)__CXXConstructor +{ using namespace poplar; +JLDebugInfo.constructor(); +} +// poplar::DebugInfo::getId()__CXXMethod +{ using namespace poplar; +JLDebugInfo.method("DebugInfoGetId", [](poplar::DebugInfo& cl) {return cl.getId();}); +} +// poplar::DebugInfo::getPathName()__CXXMethod +{ using namespace poplar; +JLDebugInfo.method("DebugInfoGetPathName", [](poplar::DebugInfo& cl) {return cl.getPathName();}); +} +// poplar::DebugInfo::initializeStreamer(const std::string &, const poplar::DebugSerializationFormat &)__CXXMethod +{ using namespace poplar; +JLDebugInfo.method("DebugInfoInitializeStreamer", [](poplar::DebugInfo& cl, const std::string & a) {return cl.initializeStreamer(a);}); +JLDebugInfo.method("DebugInfoInitializeStreamer", [](poplar::DebugInfo& cl, const std::string & a, const poplar::DebugSerializationFormat & b) {return cl.initializeStreamer(a, b);}); +} +// poplar::DebugInfo::closeStreamer()__CXXMethod +{ using namespace poplar; +JLDebugInfo.method("DebugInfoCloseStreamer", [](poplar::DebugInfo& cl) {return cl.closeStreamer();}); +} +// poplar::DebugInfo::setValue(std::string, poplar::ProfileValue)__CXXMethod +{ using namespace poplar; +JLDebugInfo.method("DebugInfoSetValue", [](poplar::DebugInfo& cl, std::string a, poplar::ProfileValue b) {return cl.setValue(a, b);}); +} +// poplar::DebugNameAndId::DebugNameAndId(std::string, poplar::DebugId, std::string)__CXXConstructor +{ using namespace poplar; +JLDebugNameAndId.constructor(); +JLDebugNameAndId.constructor(); +JLDebugNameAndId.constructor(); +} +// poplar::DebugNameAndId::DebugNameAndId(const char *)__CXXConstructor +{ using namespace poplar; +JLDebugNameAndId.constructor(); +} +// poplar::DebugNameAndId::DebugNameAndId(poplar::DebugId)__CXXConstructor +{ using namespace poplar; +JLDebugNameAndId.constructor(); +} +// poplar::DebugNameAndId::DebugNameAndId(const poplar::DebugInfo &, std::string)__CXXConstructor +{ using namespace poplar; +JLDebugNameAndId.constructor(); +JLDebugNameAndId.constructor(); +} +// poplar::DebugNameAndId::DebugNameAndId(const poplar::DebugNameAndId &, std::string)__CXXConstructor +{ using namespace poplar; +JLDebugNameAndId.constructor(); +JLDebugNameAndId.constructor(); +} +// poplar::DebugNameAndId::getPathName()__CXXMethod +{ using namespace poplar; +JLDebugNameAndId.method("DebugNameAndIdGetPathName", [](poplar::DebugNameAndId& cl) {return cl.getPathName();}); +} +// poplar::DebugContext::getPathName()__CXXMethod +{ using namespace poplar; +JLDebugContext.method("DebugContextGetPathName", [](poplar::DebugContext& cl) {return cl.getPathName();}); +} +// poplar::FunctionBufferMappingType::REMOTE__EnumConstantDecl +mod.set_const("PoplarFunctionBufferMappingTypePoplarREMOTE", poplar::FunctionBufferMappingType::REMOTE); +// poplar::VertexRef::getId()__CXXMethod +{ using namespace poplar; +JLVertexRef.method("VertexRefGetId", [](poplar::VertexRef& cl) {return cl.getId();}); +} +// poplar::FieldRef::isIndexed()__CXXMethod +{ using namespace poplar; +JLFieldRef.method("FieldRefIsIndexed", [](poplar::FieldRef& cl) {return cl.isIndexed();}); +} +// poplar::FieldRef::getIndex()__CXXMethod +{ using namespace poplar; +JLFieldRef.method("FieldRefGetIndex", [](poplar::FieldRef& cl) {return cl.getIndex();}); +} +// poplar::ComputeSet::ComputeSet(unsigned int)__CXXConstructor +{ using namespace poplar; +JLComputeSet.constructor(); +} +// poplar::ComputeSet::getId()__CXXMethod +{ using namespace poplar; +JLComputeSet.method("ComputeSetGetId", [](poplar::ComputeSet& cl) {return cl.getId();}); +} +// poplar::Function::Function(unsigned int)__CXXConstructor +{ using namespace poplar; +JLFunction.constructor(); +} +// poplar::Function::getId()__CXXMethod +{ using namespace poplar; +JLFunction.method("FunctionGetId", [](poplar::Function& cl) {return cl.getId();}); +} +// poplar::FunctionBuffer::FunctionBuffer(unsigned int)__CXXConstructor +{ using namespace poplar; +JLFunctionBuffer.constructor(); +} +// poplar::FunctionBuffer::getId()__CXXMethod +{ using namespace poplar; +JLFunctionBuffer.method("FunctionBufferGetId", [](poplar::FunctionBuffer& cl) {return cl.getId();}); +} +// poplar::HostFunction::HostFunction(unsigned int)__CXXConstructor +{ using namespace poplar; +JLHostFunction.constructor(); +} +// poplar::HostFunction::getId()__CXXMethod +{ using namespace poplar; +JLHostFunction.method("HostFunctionGetId", [](poplar::HostFunction& cl) {return cl.getId();}); +} +// poplar::ErrorCode::NONE__EnumConstantDecl +mod.set_const("PoplarErrorCodePoplarNONE", poplar::ErrorCode::NONE); +// poplar::ErrorCode::UNKNOWN__EnumConstantDecl +mod.set_const("PoplarErrorCodePoplarUNKNOWN", poplar::ErrorCode::UNKNOWN); +// poplar::ErrorCode::TRAP__EnumConstantDecl +mod.set_const("PoplarErrorCodePoplarTRAP", poplar::ErrorCode::TRAP); +// poplar::ErrorCode::FLOATING_POINT_INVALID_OPERATION__EnumConstantDecl +mod.set_const("PoplarErrorCodePoplarFLOATING_POINT_INVALID_OPERATION", poplar::ErrorCode::FLOATING_POINT_INVALID_OPERATION); +// poplar::ErrorCode::FLOATING_POINT_DIVIDE_BY_ZERO__EnumConstantDecl +mod.set_const("PoplarErrorCodePoplarFLOATING_POINT_DIVIDE_BY_ZERO", poplar::ErrorCode::FLOATING_POINT_DIVIDE_BY_ZERO); +// poplar::ErrorCode::FLOATING_POINT_OVERFLOW__EnumConstantDecl +mod.set_const("PoplarErrorCodePoplarFLOATING_POINT_OVERFLOW", poplar::ErrorCode::FLOATING_POINT_OVERFLOW); +// poplar::ErrorCode::TILE_MEMORY_BANK_CONFLICT__EnumConstantDecl +mod.set_const("PoplarErrorCodePoplarTILE_MEMORY_BANK_CONFLICT", poplar::ErrorCode::TILE_MEMORY_BANK_CONFLICT); +// poplar::ErrorCode::INVALID_EXCHANGE_CONFIGURATION__EnumConstantDecl +mod.set_const("PoplarErrorCodePoplarINVALID_EXCHANGE_CONFIGURATION", poplar::ErrorCode::INVALID_EXCHANGE_CONFIGURATION); +// poplar::ErrorCode::INVALID_ADDRESS__EnumConstantDecl +mod.set_const("PoplarErrorCodePoplarINVALID_ADDRESS", poplar::ErrorCode::INVALID_ADDRESS); +// poplar::ErrorCode::INVALID_OPERAND__EnumConstantDecl +mod.set_const("PoplarErrorCodePoplarINVALID_OPERAND", poplar::ErrorCode::INVALID_OPERAND); +// poplar::ErrorCode::INVALID_PROGRAM_COUNTER__EnumConstantDecl +mod.set_const("PoplarErrorCodePoplarINVALID_PROGRAM_COUNTER", poplar::ErrorCode::INVALID_PROGRAM_COUNTER); +// poplar::ErrorCode::INVALID_INSTRUCTION__EnumConstantDecl +mod.set_const("PoplarErrorCodePoplarINVALID_INSTRUCTION", poplar::ErrorCode::INVALID_INSTRUCTION); +// poplar::ErrorCode::EXCHANGE_ERROR__EnumConstantDecl +mod.set_const("PoplarErrorCodePoplarEXCHANGE_ERROR", poplar::ErrorCode::EXCHANGE_ERROR); +// poplar::ErrorCode::MEMORY_ERROR__EnumConstantDecl +mod.set_const("PoplarErrorCodePoplarMEMORY_ERROR", poplar::ErrorCode::MEMORY_ERROR); +// poplar::ErrorCode::IPUSOFTERR__EnumConstantDecl +mod.set_const("PoplarErrorCodePoplarIPUSOFTERR", poplar::ErrorCode::IPUSOFTERR); +// poplar::ErrorCode::LINK_DOWN__EnumConstantDecl +mod.set_const("PoplarErrorCodePoplarLINK_DOWN", poplar::ErrorCode::LINK_DOWN); +// poplar::ErrorCode::HOST_LINK_DOWN__EnumConstantDecl +mod.set_const("PoplarErrorCodePoplarHOST_LINK_DOWN", poplar::ErrorCode::HOST_LINK_DOWN); +// poplar::ErrorCode::HOST_SYNC_TIMEOUT__EnumConstantDecl +mod.set_const("PoplarErrorCodePoplarHOST_SYNC_TIMEOUT", poplar::ErrorCode::HOST_SYNC_TIMEOUT); +// poplar::ErrorCode::IPU_MEMORY_FAILURE__EnumConstantDecl +mod.set_const("PoplarErrorCodePoplarIPU_MEMORY_FAILURE", poplar::ErrorCode::IPU_MEMORY_FAILURE); +// poplar::errorCodeToString(poplar::ErrorCode)__FunctionDecl +{ using namespace poplar; +mod.method("PoplarErrorCodeToString", [](poplar::ErrorCode a) {return poplar::errorCodeToString(a);} ); } +// poplar::errorCodeFromString(std::string)__FunctionDecl +{ using namespace poplar; +mod.method("PoplarErrorCodeFromString", [](std::string a) {return poplar::errorCodeFromString(a);} ); } +// poplar::ErrorLocation::getTile()__CXXMethod +{ using namespace poplar; +JLErrorLocation.method("ErrorLocationGetTile", [](poplar::ErrorLocation& cl) {return cl.getTile();}); +} +// poplar::ErrorLocation::ErrorLocation(const poplar::ErrorLocation &)__CXXConstructor +{ using namespace poplar; +JLErrorLocation.constructor(); +} +// poplar::poplar_error::poplar_error(const std::string &)__CXXConstructor +{ using namespace poplar; +JLPoplar_error.constructor(); +} +// poplar::poplar_error::poplar_error(const char *)__CXXConstructor +{ using namespace poplar; +JLPoplar_error.constructor(); +} +// poplar::poplar_error::attachSourceLocation(const poplar::DebugContext &)__CXXMethod +{ using namespace poplar; +JLPoplar_error.method("Poplar_errorAttachSourceLocation", [](poplar::poplar_error& cl, std::string a) {return cl.attachSourceLocation(a);}); +} +// poplar::poplar_error::what()__CXXMethod +{ using namespace poplar; +JLPoplar_error.method("Poplar_errorWhat", [](poplar::poplar_error& cl) {return cl.what();}); +} +// poplar::graph_program_compilation_error::graph_program_compilation_error(const std::string &)__CXXConstructor +{ using namespace poplar; +JLGraph_program_compilation_error.constructor(); +} +// poplar::graph_program_compilation_error::graph_program_compilation_error(const char *)__CXXConstructor +{ using namespace poplar; +JLGraph_program_compilation_error.constructor(); +} +// poplar::graph_object_creation_error::graph_object_creation_error(const std::string &)__CXXConstructor +{ using namespace poplar; +JLGraph_object_creation_error.constructor(); +} +// poplar::graph_object_creation_error::graph_object_creation_error(const char *)__CXXConstructor +{ using namespace poplar; +JLGraph_object_creation_error.constructor(); +} +// poplar::graph_object_load_error::graph_object_load_error(const std::string &, const std::string &)__CXXConstructor +{ using namespace poplar; +JLGraph_object_load_error.constructor(); +} +// poplar::no_environment::no_environment(const std::string &)__CXXConstructor +{ using namespace poplar; +JLNo_environment.constructor(); +} +// poplar::no_environment::no_environment(const char *)__CXXConstructor +{ using namespace poplar; +JLNo_environment.constructor(); +} +// poplar::unknown_vertex_type::unknown_vertex_type(const std::string &)__CXXConstructor +{ using namespace poplar; +JLUnknown_vertex_type.constructor(); +} +// poplar::unknown_field::unknown_field(const std::string &)__CXXConstructor +{ using namespace poplar; +JLUnknown_field.constructor(); +} +// poplar::unknown_field::unknown_field(const char *)__CXXConstructor +{ using namespace poplar; +JLUnknown_field.constructor(); +} +// poplar::unknown_field::unknown_field(const std::string &, const std::string &)__CXXConstructor +{ using namespace poplar; +JLUnknown_field.constructor(); +} +// poplar::control_program_error::control_program_error(const std::string &)__CXXConstructor +{ using namespace poplar; +JLControl_program_error.constructor(); +} +// poplar::type_error::type_error(const std::string &)__CXXConstructor +{ using namespace poplar; +JLType_error.constructor(); +} +// poplar::type_error::type_error(const char *)__CXXConstructor +{ using namespace poplar; +JLType_error.constructor(); +} +// poplar::index_error::index_error(const std::string &)__CXXConstructor +{ using namespace poplar; +JLIndex_error.constructor(); +} +// poplar::index_error::index_error(const char *)__CXXConstructor +{ using namespace poplar; +JLIndex_error.constructor(); +} +// poplar::index_error::index_error(const std::string &, std::size_t)__CXXConstructor +{ using namespace poplar; +JLIndex_error.constructor(); +} +// poplar::no_size_specified::no_size_specified(const std::string &)__CXXConstructor +{ using namespace poplar; +JLNo_size_specified.constructor(); +} +// poplar::no_size_specified::no_size_specified(const char *)__CXXConstructor +{ using namespace poplar; +JLNo_size_specified.constructor(); +} +// poplar::no_size_specified::no_size_specified(const std::string &, const std::string &)__CXXConstructor +{ using namespace poplar; +JLNo_size_specified.constructor(); +} +// poplar::graph_connection_error::graph_connection_error(const std::string &)__CXXConstructor +{ using namespace poplar; +JLGraph_connection_error.constructor(); +} +// poplar::graph_connection_error::graph_connection_error(const char *)__CXXConstructor +{ using namespace poplar; +JLGraph_connection_error.constructor(); +} +// poplar::graph_cycle_error::graph_cycle_error(const std::string &)__CXXConstructor +{ using namespace poplar; +JLGraph_cycle_error.constructor(); +} +// poplar::graph_cycle_error::graph_cycle_error(const char *)__CXXConstructor +{ using namespace poplar; +JLGraph_cycle_error.constructor(); +} +// poplar::graph_recursion_error::graph_recursion_error(const std::string &)__CXXConstructor +{ using namespace poplar; +JLGraph_recursion_error.constructor(); +} +// poplar::graph_recursion_error::graph_recursion_error(const char *)__CXXConstructor +{ using namespace poplar; +JLGraph_recursion_error.constructor(); +} +// poplar::graph_replication_error::graph_replication_error(const std::string &)__CXXConstructor +{ using namespace poplar; +JLGraph_replication_error.constructor(); +} +// poplar::graph_replication_error::graph_replication_error(const char *)__CXXConstructor +{ using namespace poplar; +JLGraph_replication_error.constructor(); +} +// poplar::missing_graph_profile::missing_graph_profile(const std::string &)__CXXConstructor +{ using namespace poplar; +JLMissing_graph_profile.constructor(); +} +// poplar::missing_graph_profile::missing_graph_profile(const char *)__CXXConstructor +{ using namespace poplar; +JLMissing_graph_profile.constructor(); +} +// poplar::missing_perf_estimate::missing_perf_estimate(const std::string &)__CXXConstructor +{ using namespace poplar; +JLMissing_perf_estimate.constructor(); +} +// poplar::invalid_tile_mapping::invalid_tile_mapping(const std::string &)__CXXConstructor +{ using namespace poplar; +JLInvalid_tile_mapping.constructor(); +} +// poplar::invalid_tile_mapping::invalid_tile_mapping(const char *)__CXXConstructor +{ using namespace poplar; +JLInvalid_tile_mapping.constructor(); +} +// poplar::tensor_creation_error::tensor_creation_error(const std::string &)__CXXConstructor +{ using namespace poplar; +JLTensor_creation_error.constructor(); +} +// poplar::tensor_creation_error::tensor_creation_error(const char *)__CXXConstructor +{ using namespace poplar; +JLTensor_creation_error.constructor(); +} +// poplar::tensor_io_state_error::tensor_io_state_error(const std::string &)__CXXConstructor +{ using namespace poplar; +JLTensor_io_state_error.constructor(); +} +// poplar::tensor_io_state_error::tensor_io_state_error(const char *)__CXXConstructor +{ using namespace poplar; +JLTensor_io_state_error.constructor(); +} +// poplar::tensor_metadata_error::tensor_metadata_error(const std::string &)__CXXConstructor +{ using namespace poplar; +JLTensor_metadata_error.constructor(); +} +// poplar::tensor_metadata_error::tensor_metadata_error(const char *)__CXXConstructor +{ using namespace poplar; +JLTensor_metadata_error.constructor(); +} +// poplar::stream_connection_error::stream_connection_error(const std::string &)__CXXConstructor +{ using namespace poplar; +JLStream_connection_error.constructor(); +} +// poplar::stream_connection_error::stream_connection_error(const char *)__CXXConstructor +{ using namespace poplar; +JLStream_connection_error.constructor(); +} +// poplar::overflow_error::overflow_error(const std::string &)__CXXConstructor +{ using namespace poplar; +JLOverflow_error.constructor(); +} +// poplar::overflow_error::overflow_error(const char *)__CXXConstructor +{ using namespace poplar; +JLOverflow_error.constructor(); +} +// poplar::memory_elem_constraints_error::memory_elem_constraints_error(const std::string &)__CXXConstructor +{ using namespace poplar; +JLMemory_elem_constraints_error.constructor(); +} +// poplar::memory_elem_constraints_error::memory_elem_constraints_error(const char *)__CXXConstructor +{ using namespace poplar; +JLMemory_elem_constraints_error.constructor(); +} +// poplar::graph_memory_allocation_error::graph_memory_allocation_error(const std::string &)__CXXConstructor +{ using namespace poplar; +JLGraph_memory_allocation_error.constructor(); +} +// poplar::graph_memory_allocation_error::graph_memory_allocation_error(const char *)__CXXConstructor +{ using namespace poplar; +JLGraph_memory_allocation_error.constructor(); +} +// poplar::stream_memory_allocation_error::stream_memory_allocation_error(const std::string &)__CXXConstructor +{ using namespace poplar; +JLStream_memory_allocation_error.constructor(); +} +// poplar::stream_memory_allocation_error::stream_memory_allocation_error(const char *)__CXXConstructor +{ using namespace poplar; +JLStream_memory_allocation_error.constructor(); +} +// poplar::invalid_machine_model::invalid_machine_model(const std::string &)__CXXConstructor +{ using namespace poplar; +JLInvalid_machine_model.constructor(); +} +// poplar::invalid_machine_model::invalid_machine_model(const char *)__CXXConstructor +{ using namespace poplar; +JLInvalid_machine_model.constructor(); +} +// poplar::invalid_option::invalid_option(const std::string &)__CXXConstructor +{ using namespace poplar; +JLInvalid_option.constructor(); +} +// poplar::invalid_option::invalid_option(const char *)__CXXConstructor +{ using namespace poplar; +JLInvalid_option.constructor(); +} +// poplar::link_error::link_error(const std::string &, const std::string &)__CXXConstructor +{ using namespace poplar; +JLLink_error.constructor(); +JLLink_error.constructor(); +} +// poplar::link_error::link_error(const char *, const char *)__CXXConstructor +{ using namespace poplar; +JLLink_error.constructor(); +JLLink_error.constructor(); +} +// poplar::runtime_error::runtime_error(const std::string &)__CXXConstructor +{ using namespace poplar; +JLRuntime_error.constructor(); +} +// poplar::runtime_error::runtime_error(const char *)__CXXConstructor +{ using namespace poplar; +JLRuntime_error.constructor(); +} +// poplar::application_runtime_error::application_runtime_error(const std::string &)__CXXConstructor +{ using namespace poplar; +JLApplication_runtime_error.constructor(); +} +// poplar::application_runtime_error::application_runtime_error(const char *)__CXXConstructor +{ using namespace poplar; +JLApplication_runtime_error.constructor(); +} +// poplar::system_runtime_error::system_runtime_error(const std::string &)__CXXConstructor +{ using namespace poplar; +JLSystem_runtime_error.constructor(); +} +// poplar::system_runtime_error::system_runtime_error(const char *)__CXXConstructor +{ using namespace poplar; +JLSystem_runtime_error.constructor(); +} +// poplar::RecoveryAction::IPU_RESET__EnumConstantDecl +mod.set_const("PoplarRecoveryActionPoplarIPU_RESET", poplar::RecoveryAction::IPU_RESET); +// poplar::RecoveryAction::PARTITION_RESET__EnumConstantDecl +mod.set_const("PoplarRecoveryActionPoplarPARTITION_RESET", poplar::RecoveryAction::PARTITION_RESET); +// poplar::RecoveryAction::FULL_RESET__EnumConstantDecl +mod.set_const("PoplarRecoveryActionPoplarFULL_RESET", poplar::RecoveryAction::FULL_RESET); +// poplar::recoverable_runtime_error::getRecoveryAction()__CXXMethod +{ using namespace poplar; +JLRecoverable_runtime_error.method("Recoverable_runtime_errorGetRecoveryAction", [](poplar::recoverable_runtime_error& cl) {return cl.getRecoveryAction();}); +} +// poplar::recoverable_runtime_error::recoverable_runtime_error(poplar::RecoveryAction, const std::string &)__CXXConstructor +{ using namespace poplar; +JLRecoverable_runtime_error.constructor(); +} +// poplar::recoverable_runtime_error::recoverable_runtime_error(poplar::RecoveryAction, const char *)__CXXConstructor +{ using namespace poplar; +JLRecoverable_runtime_error.constructor(); +} +// poplar::unrecoverable_runtime_error::unrecoverable_runtime_error(const std::string &)__CXXConstructor +{ using namespace poplar; +JLUnrecoverable_runtime_error.constructor(); +} +// poplar::unrecoverable_runtime_error::unrecoverable_runtime_error(const char *)__CXXConstructor +{ using namespace poplar; +JLUnrecoverable_runtime_error.constructor(); +} +// poplar::unknown_runtime_error::unknown_runtime_error(const std::string &)__CXXConstructor +{ using namespace poplar; +JLUnknown_runtime_error.constructor(); +} +// poplar::unknown_runtime_error::unknown_runtime_error(const char *)__CXXConstructor +{ using namespace poplar; +JLUnknown_runtime_error.constructor(); +} +// poplar::symbol_error::symbol_error(const std::string &, const unsigned int)__CXXConstructor +{ using namespace poplar; +JLSymbol_error.constructor(); +} +// poplar::file_load_error::file_load_error(const std::string &)__CXXConstructor +{ using namespace poplar; +JLFile_load_error.constructor(); +} +// poplar::parse_error::parse_error(const std::string &)__CXXConstructor +{ using namespace poplar; +JLParse_error.constructor(); +} +// poplar::parse_error::parse_error(const char *)__CXXConstructor +{ using namespace poplar; +JLParse_error.constructor(); +} +// poplar::SyncType::INTERNAL__EnumConstantDecl +mod.set_const("PoplarSyncTypePoplarINTERNAL", poplar::SyncType::INTERNAL); +// poplar::SyncType::EXTERNAL__EnumConstantDecl +mod.set_const("PoplarSyncTypePoplarEXTERNAL", poplar::SyncType::EXTERNAL); +// poplar::SyncType::GLOBAL__EnumConstantDecl +mod.set_const("PoplarSyncTypePoplarGLOBAL", poplar::SyncType::GLOBAL); +// poplar::TypeTraits::isSimpleType()__CXXMethod +{ using namespace poplar; +JLTypeTraits.method("TypeTraitsIsSimpleType", [](poplar::TypeTraits& cl) {return cl.isSimpleType();}); +} +// poplar::TypeTraits::make<>()__CXXMethod +{ using namespace poplar; +JLTypeTraits.method("TypeTraitsMake<>", [](poplar::TypeTraits& cl) {return cl.make<>();}); +} +// poplar::TypeTraits::isSimpleType<>()__CXXMethod +{ using namespace poplar; +JLTypeTraits.method("TypeTraitsIsSimpleType<>", [](poplar::TypeTraits& cl) {return cl.isSimpleType<>();}); +} +// poplar::TypeTraits::requiresMetadata<>()__CXXMethod +{ using namespace poplar; +JLTypeTraits.method("TypeTraitsRequiresMetadata<>", [](poplar::TypeTraits& cl) {return cl.requiresMetadata<>();}); +} +// poplar::UpsampleMethod::REPEAT__EnumConstantDecl +mod.set_const("PoplarUpsampleMethodPoplarREPEAT", poplar::UpsampleMethod::REPEAT); +// poplar::Tensor::Tensor(const poplar::Tensor &)__CXXConstructor +{ using namespace poplar; +JLTensor.constructor(); +} +// poplar::Tensor::elementType()__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorElementType", [](poplar::Tensor& cl) {return cl.elementType();}); +} +// poplar::Tensor::slice(std::size_t, std::size_t, unsigned int)__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorSlice", [](poplar::Tensor& cl, std::size_t a, std::size_t b, unsigned int c) {return cl.slice(a, b, c);}); +} +// poplar::Tensor::slice(std::size_t, std::size_t)__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorSlice", [](poplar::Tensor& cl, std::size_t a, std::size_t b) {return cl.slice(a, b);}); +} +// poplar::Tensor::slice(const poplar::Interval &, unsigned int)__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorSlice", [](poplar::Tensor& cl, const poplar::Interval & a) {return cl.slice(a);}); +JLTensor.method("TensorSlice", [](poplar::Tensor& cl, const poplar::Interval & a, unsigned int b) {return cl.slice(a, b);}); +} +// poplar::Tensor::slice(ArrayRef, ArrayRef)__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorSlice", [](poplar::Tensor& cl, jlcxx::ArrayRef a, jlcxx::ArrayRef b) {return cl.slice(jlcxxToPoplar(a), jlcxxToPoplar(b));}); +} +// poplar::Tensor::slices(ArrayRef, unsigned int)__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorSlices", [](poplar::Tensor& cl, ArrayRef a) {return cl.slices(a);}); +JLTensor.method("TensorSlices", [](poplar::Tensor& cl, ArrayRef a, unsigned int b) {return cl.slices(a, b);}); +} +// poplar::Tensor::slices(const std::vector> &, unsigned int)__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorSlices", [](poplar::Tensor& cl, const std::vector> & a) {return cl.slices(a);}); +JLTensor.method("TensorSlices", [](poplar::Tensor& cl, const std::vector> & a, unsigned int b) {return cl.slices(a, b);}); +} +// poplar::Tensor::slices(const poplar::ArrayRef &, unsigned int)__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorSlices", [](poplar::Tensor& cl, const poplar::ArrayRef & a) {return cl.slices(a);}); +JLTensor.method("TensorSlices", [](poplar::Tensor& cl, const poplar::ArrayRef & a, unsigned int b) {return cl.slices(a, b);}); +} +// poplar::Tensor::index(ArrayRef)__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorIndex", [](poplar::Tensor& cl, jlcxx::ArrayRef a) {return cl.index(jlcxxToPoplar(a));}); +} +// poplar::Tensor::flatten()__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorFlatten", [](poplar::Tensor& cl) {return cl.flatten();}); +} +// poplar::Tensor::flatten(unsigned int, unsigned int)__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorFlatten", [](poplar::Tensor& cl, unsigned int a, unsigned int b) {return cl.flatten(a, b);}); +} +// poplar::Tensor::reshape(ArrayRef)__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorReshape", [](poplar::Tensor& cl, jlcxx::ArrayRef a) {return cl.reshape(jlcxxToPoplar(a));}); +} +// poplar::Tensor::dimShuffle(ArrayRef)__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorDimShuffle", [](poplar::Tensor& cl, jlcxx::ArrayRef a) {return cl.dimShuffle(jlcxxToPoplar(a));}); +} +// poplar::Tensor::dimShufflePartial(ArrayRef, ArrayRef)__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorDimShufflePartial", [](poplar::Tensor& cl, jlcxx::ArrayRef a, jlcxx::ArrayRef b) {return cl.dimShufflePartial(jlcxxToPoplar(a), jlcxxToPoplar(b));}); +} +// poplar::Tensor::dimRoll(unsigned int, unsigned int)__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorDimRoll", [](poplar::Tensor& cl, unsigned int a) {return cl.dimRoll(a);}); +JLTensor.method("TensorDimRoll", [](poplar::Tensor& cl, unsigned int a, unsigned int b) {return cl.dimRoll(a, b);}); +} +// poplar::Tensor::reshapePartial(unsigned int, unsigned int, ArrayRef)__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorReshapePartial", [](poplar::Tensor& cl, unsigned int a, unsigned int b, jlcxx::ArrayRef c) {return cl.reshapePartial(a, b, jlcxxToPoplar(c));}); +} +// poplar::Tensor::expand(ArrayRef)__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorExpand", [](poplar::Tensor& cl, jlcxx::ArrayRef a) {return cl.expand(jlcxxToPoplar(a));}); +} +// poplar::Tensor::squeeze(ArrayRef)__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorSqueeze", [](poplar::Tensor& cl, jlcxx::ArrayRef a) {return cl.squeeze(jlcxxToPoplar(a));}); +} +// poplar::Tensor::transpose()__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorTranspose", [](poplar::Tensor& cl) {return cl.transpose();}); +} +// poplar::Tensor::subSample(unsigned int, unsigned int)__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorSubSample", [](poplar::Tensor& cl, unsigned int a, unsigned int b) {return cl.subSample(a, b);}); +} +// poplar::Tensor::upsample(unsigned int, unsigned int, poplar::UpsampleMethod)__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorUpsample", [](poplar::Tensor& cl, unsigned int a, unsigned int b, poplar::UpsampleMethod c) {return cl.upsample(a, b, c);}); +} +// poplar::Tensor::broadcast(unsigned int, unsigned int)__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorBroadcast", [](poplar::Tensor& cl, unsigned int a, unsigned int b) {return cl.broadcast(a, b);}); +} +// poplar::Tensor::reinterpret(const poplar::Type &)__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorReinterpret", [](poplar::Tensor& cl, const poplar::Type & a) {return cl.reinterpret(a);}); +} +// poplar::Tensor::reverse(unsigned int)__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorReverse", [](poplar::Tensor& cl, unsigned int a) {return cl.reverse(a);}); +} +// poplar::Tensor::numElements()__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorNumElements", [](poplar::Tensor& cl) {return cl.numElements();}); +} +// poplar::Tensor::dim(unsigned int)__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorDim", [](poplar::Tensor& cl, unsigned int a) {return cl.dim(a);}); +} +// poplar::Tensor::shape()__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorShape", [](poplar::Tensor& cl) {return cl.shape();}); +} +// poplar::Tensor::rank()__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorRank", [](poplar::Tensor& cl) {return cl.rank();}); +} +// poplar::Tensor::isContiguous()__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorIsContiguous", [](poplar::Tensor& cl) {return cl.isContiguous();}); +} +// poplar::Tensor::containsAliases()__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorContainsAliases", [](poplar::Tensor& cl) {return cl.containsAliases();}); +} +// poplar::Tensor::containsConstant()__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorContainsConstant", [](poplar::Tensor& cl) {return cl.containsConstant();}); +} +// poplar::Tensor::isParallelWriteable()__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorIsParallelWriteable", [](poplar::Tensor& cl) {return cl.isParallelWriteable();}); +} +// poplar::Tensor::getContiguousRegions()__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorGetContiguousRegions", [](poplar::Tensor& cl) {return cl.getContiguousRegions();}); +} +// poplar::Tensor::getVarRegions()__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorGetVarRegions", [](poplar::Tensor& cl) {return cl.getVarRegions();}); +} +// poplar::Tensor::intersectsWith(const poplar::Tensor &)__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorIntersectsWith", [](poplar::Tensor& cl, const poplar::Tensor & a) {return cl.intersectsWith(a);}); +} +// poplar::Tensor::shapeToString()__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorShapeToString", [](poplar::Tensor& cl) {return cl.shapeToString();}); +} +// poplar::Tensor::dump()__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorDump", [](poplar::Tensor& cl) {return cl.dump();}); +} +// poplar::Tensor::dumpRegions()__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorDumpRegions", [](poplar::Tensor& cl) {return cl.dumpRegions();}); +} +// poplar::Tensor::getVarStr()__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorGetVarStr", [](poplar::Tensor& cl) {return cl.getVarStr();}); +} +// poplar::Tensor::getDebugStr()__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorGetDebugStr", [](poplar::Tensor& cl) {return cl.getDebugStr();}); +} +// poplar::Tensor::valid()__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorValid", [](poplar::Tensor& cl) {return cl.valid();}); +} +// poplar::Tensor::getMetadata()__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorGetMetadata", [](poplar::Tensor& cl) {return cl.getMetadata();}); +} +// poplar::Tensor::hasMetadata()__CXXMethod +{ using namespace poplar; +JLTensor.method("TensorHasMetadata", [](poplar::Tensor& cl) {return cl.hasMetadata();}); +} +// poplar::concat(ArrayRef, unsigned int)__FunctionDecl +{ using namespace poplar; +mod.method("PoplarConcat", [](ArrayRef a, unsigned int b) {return poplar::concat(a, b);} ); } +// poplar::concat(const poplar::Tensor &, const poplar::Tensor &, unsigned int)__FunctionDecl +{ using namespace poplar; +mod.method("PoplarConcat", [](const poplar::Tensor & a, const poplar::Tensor & b, unsigned int c) {return poplar::concat(a, b, c);} ); } +// poplar::append(const poplar::Tensor &, const poplar::Tensor &, unsigned int)__FunctionDecl +{ using namespace poplar; +mod.method("PoplarAppend", [](const poplar::Tensor & a, const poplar::Tensor & b, unsigned int c) {return poplar::append(a, b, c);} ); } +// poplar::append(const poplar::Tensor &, const poplar::Tensor &)__FunctionDecl +{ using namespace poplar; +mod.method("PoplarAppend", [](const poplar::Tensor & a, const poplar::Tensor & b) {return poplar::append(a, b);} ); } +// poplar::program::Program::Program(const poplar::program::Program &)__CXXConstructor +{ using namespace poplar::program; +JLProgramProgram.constructor(); +} +// poplar::program::Program::isEmpty()__CXXMethod +{ using namespace poplar::program; +JLProgramProgram.method("ProgramProgramIsEmpty", [](poplar::program::Program& cl) {return cl.isEmpty();}); +} +// poplar::program::Execute::Execute(poplar::ComputeSet, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramExecute.constructor(); +JLProgramExecute.constructor(); +} +// poplar::program::Execute::Execute(poplar::ComputeSet, poplar::Tensor, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramExecute.constructor(); +JLProgramExecute.constructor(); +} +// poplar::program::Sequence::add(const poplar::program::Program &)__CXXMethod +{ using namespace poplar::program; +JLProgramSequence.method("ProgramSequenceAdd", [](poplar::program::Sequence& cl, const poplar::program::Program & a) {return cl.add(a);}); +} +// poplar::program::Repeat::Repeat(unsigned int, const poplar::program::Program &, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramRepeat.constructor(); +JLProgramRepeat.constructor(); +} +// poplar::program::RepeatWhileFalse::RepeatWhileFalse(const poplar::program::Program &, poplar::Tensor, const poplar::program::Program &, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramRepeatWhileFalse.constructor(); +JLProgramRepeatWhileFalse.constructor(); +} +// poplar::program::RepeatWhileTrue::RepeatWhileTrue(const poplar::program::Program &, poplar::Tensor, const poplar::program::Program &, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramRepeatWhileTrue.constructor(); +JLProgramRepeatWhileTrue.constructor(); +} +// poplar::program::Loop::Loop(const poplar::program::Program &, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramLoop.constructor(); +JLProgramLoop.constructor(); +} +// poplar::program::If::If(poplar::Tensor, const poplar::program::Program &, const poplar::program::Program &, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramIf.constructor(); +JLProgramIf.constructor(); +} +// poplar::program::Switch::Switch(poplar::Tensor, const std::vector> &, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramSwitch.constructor> &>(); +JLProgramSwitch.constructor> &, std::string>(); +} +// poplar::program::Switch::Switch(poplar::Tensor, const std::vector> &, const poplar::program::Program &, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramSwitch.constructor> &, const poplar::program::Program &>(); +JLProgramSwitch.constructor> &, const poplar::program::Program &, std::string>(); +} +// poplar::program::Switch::Switch(poplar::Tensor, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramSwitch.constructor(); +JLProgramSwitch.constructor(); +} +// poplar::program::Switch::Switch(poplar::Tensor, const poplar::program::Program &, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramSwitch.constructor(); +JLProgramSwitch.constructor(); +} +// poplar::program::Switch::add(std::int32_t, const poplar::program::Program &)__CXXMethod +{ using namespace poplar::program; +JLProgramSwitch.method("ProgramSwitchAdd", [](poplar::program::Switch& cl, std::int32_t a, const poplar::program::Program & b) {return cl.add(a, b);}); +} +// poplar::program::Switch::switchWithBoundsChecking(poplar::Tensor, const std::vector> &, const poplar::DebugContext &)__CXXMethod +{ using namespace poplar::program; +JLProgramSwitch.method("ProgramSwitchSwitchWithBoundsChecking", [](poplar::program::Switch& cl, poplar::Tensor a, const std::vector> & b) {return cl.switchWithBoundsChecking(a, b);}); +JLProgramSwitch.method("ProgramSwitchSwitchWithBoundsChecking", [](poplar::program::Switch& cl, poplar::Tensor a, const std::vector> & b, std::string c) {return cl.switchWithBoundsChecking(a, b, c);}); +} +// poplar::program::Switch::switchWithUnreachableDefault(poplar::Tensor, const poplar::DebugContext &)__CXXMethod +{ using namespace poplar::program; +JLProgramSwitch.method("ProgramSwitchSwitchWithUnreachableDefault", [](poplar::program::Switch& cl, poplar::Tensor a) {return cl.switchWithUnreachableDefault(a);}); +JLProgramSwitch.method("ProgramSwitchSwitchWithUnreachableDefault", [](poplar::program::Switch& cl, poplar::Tensor a, std::string b) {return cl.switchWithUnreachableDefault(a, b);}); +} +// poplar::program::Copy::Copy(poplar::Tensor, poplar::Tensor, bool, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramCopy.constructor(); +JLProgramCopy.constructor(); +JLProgramCopy.constructor(); +} +// poplar::program::Copy::Copy(const poplar::DataStream &, poplar::Tensor, bool, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramCopy.constructor(); +JLProgramCopy.constructor(); +JLProgramCopy.constructor(); +} +// poplar::program::Copy::Copy(poplar::Tensor, const poplar::DataStream &, bool, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramCopy.constructor(); +JLProgramCopy.constructor(); +JLProgramCopy.constructor(); +} +// poplar::program::Copy::Copy(const poplar::RemoteBuffer &, poplar::Tensor, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramCopy.constructor(); +JLProgramCopy.constructor(); +} +// poplar::program::Copy::Copy(const poplar::RemoteBuffer &, poplar::Tensor, poplar::Tensor, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramCopy.constructor(); +JLProgramCopy.constructor(); +} +// poplar::program::Copy::Copy(poplar::Tensor, const poplar::RemoteBuffer &, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramCopy.constructor(); +JLProgramCopy.constructor(); +} +// poplar::program::Copy::Copy(poplar::Tensor, const poplar::RemoteBuffer &, poplar::Tensor, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramCopy.constructor(); +JLProgramCopy.constructor(); +} +// poplar::program::Copy::Copy(const poplar::FunctionBuffer &, const poplar::Function &, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramCopy.constructor(); +JLProgramCopy.constructor(); +} +// poplar::program::CrossReplicaCopy::CrossReplicaCopy(poplar::Tensor, poplar::Tensor, std::map, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramCrossReplicaCopy.constructor>(); +JLProgramCrossReplicaCopy.constructor, std::string>(); +} +// poplar::program::WriteUndef::WriteUndef(poplar::Tensor, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramWriteUndef.constructor(); +JLProgramWriteUndef.constructor(); +} +// poplar::program::AssumeEqualAcrossReplicas::AssumeEqualAcrossReplicas(poplar::Tensor, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramAssumeEqualAcrossReplicas.constructor(); +JLProgramAssumeEqualAcrossReplicas.constructor(); +} +// poplar::program::Block::Block(const poplar::program::Program &, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramBlock.constructor(); +JLProgramBlock.constructor(); +} +// poplar::program::Sync::Sync(poplar::SyncType, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramSync.constructor(); +JLProgramSync.constructor(); +} +// poplar::program::Call::Call(poplar::Function, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramCall.constructor(); +JLProgramCall.constructor(); +} +// poplar::program::Call::Call(poplar::HostFunction, ArrayRef, ArrayRef, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramCall.constructor, ArrayRef>(); +JLProgramCall.constructor, ArrayRef, std::string>(); +} +// poplar::program::PrintTensor::PrintTensor(poplar::Tensor, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramPrintTensor.constructor(); +JLProgramPrintTensor.constructor(); +} +// poplar::program::PrintTensor::PrintTensor(std::string, poplar::Tensor, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramPrintTensor.constructor(); +JLProgramPrintTensor.constructor(); +} +// poplar::program::ErrorProgram::ErrorProgram(std::string, poplar::Tensor, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramErrorProgram.constructor(); +JLProgramErrorProgram.constructor(); +} +// poplar::program::Abort::Abort(const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramAbort.constructor(); +} +// poplar::program::Abort::Abort(const std::string &, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramAbort.constructor(); +JLProgramAbort.constructor(); +} +// poplar::program::AbortOnCondition::AbortOnCondition(poplar::Tensor, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramAbortOnCondition.constructor(); +JLProgramAbortOnCondition.constructor(); +} +// poplar::program::AbortOnCondition::AbortOnCondition(poplar::Tensor, const std::string &, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramAbortOnCondition.constructor(); +JLProgramAbortOnCondition.constructor(); +} +// poplar::TensorCloneMethod::PRESERVE_ORDER_AND_ALIASES__EnumConstantDecl +mod.set_const("PoplarTensorCloneMethodPoplarPRESERVE_ORDER_AND_ALIASES", poplar::TensorCloneMethod::PRESERVE_ORDER_AND_ALIASES); +// poplar::TensorCloneMethod::CREATE_NEW_ORDER__EnumConstantDecl +mod.set_const("PoplarTensorCloneMethodPoplarCREATE_NEW_ORDER", poplar::TensorCloneMethod::CREATE_NEW_ORDER); +// poplar::TensorCloneMethod::PRESERVE_ORDER_UNLESS_ALIASES__EnumConstantDecl +mod.set_const("PoplarTensorCloneMethodPoplarPRESERVE_ORDER_UNLESS_ALIASES", poplar::TensorCloneMethod::PRESERVE_ORDER_UNLESS_ALIASES); +// poplar::TensorCloneMethod::GATHER_AND_PRESERVE_TILE_ORDER_AND_ALIASES__EnumConstantDecl +mod.set_const("PoplarTensorCloneMethodPoplarGATHER_AND_PRESERVE_TILE_ORDER_AND_ALIASES", poplar::TensorCloneMethod::GATHER_AND_PRESERVE_TILE_ORDER_AND_ALIASES); +// poplar::TensorCloneDuplicationMethod::DUPLICATE_BY_OUTER_DIMENSION__EnumConstantDecl +mod.set_const("PoplarTensorCloneDuplicationMethodPoplarDUPLICATE_BY_OUTER_DIMENSION", poplar::TensorCloneDuplicationMethod::DUPLICATE_BY_OUTER_DIMENSION); +// poplar::TensorCloneDuplicationMethod::DUPLICATE_BY_TILE_CONTIGUOUS_REGION__EnumConstantDecl +mod.set_const("PoplarTensorCloneDuplicationMethodPoplarDUPLICATE_BY_TILE_CONTIGUOUS_REGION", poplar::TensorCloneDuplicationMethod::DUPLICATE_BY_TILE_CONTIGUOUS_REGION); +// poplar::TensorRearranger::TensorRearranger(const poplar::TensorRearranger &)__CXXConstructor +{ using namespace poplar; +JLTensorRearranger.constructor(); +} +// poplar::TensorRearranger::rearrange(const poplar::Tensor &)__CXXMethod +{ using namespace poplar; +JLTensorRearranger.method("TensorRearrangerRearrange", [](poplar::TensorRearranger& cl, const poplar::Tensor & a) {return cl.rearrange(a);}); +} +// poplar::TensorRearranger::undoRearrangement(const poplar::Tensor &)__CXXMethod +{ using namespace poplar; +JLTensorRearranger.method("TensorRearrangerUndoRearrangement", [](poplar::TensorRearranger& cl, const poplar::Tensor & a) {return cl.undoRearrangement(a);}); +} +// poplar::TensorRearranger::rearrange(ArrayRef)__CXXMethod +{ using namespace poplar; +JLTensorRearranger.method("TensorRearrangerRearrange", [](poplar::TensorRearranger& cl, ArrayRef a) {return cl.rearrange(a);}); +} +// poplar::TensorRearranger::undoRearrangement(ArrayRef)__CXXMethod +{ using namespace poplar; +JLTensorRearranger.method("TensorRearrangerUndoRearrangement", [](poplar::TensorRearranger& cl, ArrayRef a) {return cl.undoRearrangement(a);}); +} +// poplar::TensorRearranger::valid()__CXXMethod +{ using namespace poplar; +JLTensorRearranger.method("TensorRearrangerValid", [](poplar::TensorRearranger& cl) {return cl.valid();}); +} +// poplar::VariableMappingMethod::NONE__EnumConstantDecl +mod.set_const("PoplarVariableMappingMethodPoplarNONE", poplar::VariableMappingMethod::NONE); +// poplar::VariableMappingMethod::LINEAR__EnumConstantDecl +mod.set_const("PoplarVariableMappingMethodPoplarLINEAR", poplar::VariableMappingMethod::LINEAR); +// poplar::VariableRef::VariableRef(unsigned int)__CXXConstructor +{ using namespace poplar; +JLVariableRef.constructor(); +} +// poplar::VariableRef::VariableRef(const poplar::VariableRef &)__CXXConstructor +{ using namespace poplar; +JLVariableRef.constructor(); +} +// poplar::VariableRef::hash()__CXXMethod +{ using namespace poplar; +JLVariableRef.method("VariableRefHash", [](poplar::VariableRef& cl) {return cl.hash();}); +} +// poplar::VariableInterval::VariableInterval(poplar::VariableRef, poplar::Interval)__CXXConstructor +{ using namespace poplar; +JLVariableInterval.constructor(); +} +// poplar::VariableInterval::VariableInterval(const poplar::VariableInterval &)__CXXConstructor +{ using namespace poplar; +JLVariableInterval.constructor(); +} +// poplar::FieldData::rank()__CXXMethod +{ using namespace poplar; +JLFieldData.method("FieldDataRank", [](poplar::FieldData& cl) {return cl.rank();}); +} +// poplar::FieldData::size()__CXXMethod +{ using namespace poplar; +JLFieldData.method("FieldDataSize", [](poplar::FieldData& cl) {return cl.size();}); +} +// poplar::FieldData::getSizeAtIndex(std::size_t)__CXXMethod +{ using namespace poplar; +JLFieldData.method("FieldDataGetSizeAtIndex", [](poplar::FieldData& cl, std::size_t a) {return cl.getSizeAtIndex(a);}); +} +// poplar::FieldData::getProfilerVectorLayout(std::size_t)__CXXMethod +{ using namespace poplar; +JLFieldData.method("FieldDataGetProfilerVectorLayout", [](poplar::FieldData& cl, std::size_t a) {return cl.getProfilerVectorLayout(a);}); +} +// poplar::FieldData::getProfilerVectorListLayout()__CXXMethod +{ using namespace poplar; +JLFieldData.method("FieldDataGetProfilerVectorListLayout", [](poplar::FieldData& cl) {return cl.getProfilerVectorListLayout();}); +} +// poplar::FieldData::name()__CXXMethod +{ using namespace poplar; +JLFieldData.method("FieldDataName", [](poplar::FieldData& cl) {return cl.name();}); +} +// poplar::replication_factor::replication_factor(unsigned int)__CXXConstructor +{ using namespace poplar; +JLReplication_factor.constructor(); +} +// poplar::versionString()__FunctionDecl +{ using namespace poplar; +mod.method("PoplarVersionString", []() {return poplar::versionString();} ); } +// poplar::packageHash()__FunctionDecl +{ using namespace poplar; +mod.method("PoplarPackageHash", []() {return poplar::packageHash();} ); } +// poplar::Graph::Graph(const poplar::Target &, poplar::replication_factor)__CXXConstructor +{ using namespace poplar; +JLGraph.constructor(); +JLGraph.constructor(); +} +// poplar::Graph::Graph(const poplar::Device &, poplar::replication_factor)__CXXConstructor +{ using namespace poplar; +JLGraph.constructor(); +JLGraph.constructor(); +} +// poplar::Graph::getTarget()__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphGetTarget", [](poplar::Graph& cl) {return cl.getTarget();}); +} +// poplar::Graph::addCodelets(std::string, poplar::CodeletFileType, std::string, std::string)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, std::string a) {return cl.addCodelets(a);}); +JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, std::string a, poplar::CodeletFileType b) {return cl.addCodelets(a, b);}); +JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, std::string a, poplar::CodeletFileType b, std::string c) {return cl.addCodelets(a, b, c);}); +JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, std::string a, poplar::CodeletFileType b, std::string c, std::string d) {return cl.addCodelets(a, b, c, d);}); +} +// poplar::Graph::addCodelets(ArrayRef, std::string, std::string)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, ArrayRef a) {return cl.addCodelets(a);}); +JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, ArrayRef a, std::string b) {return cl.addCodelets(a, b);}); +JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, ArrayRef a, std::string b, std::string c) {return cl.addCodelets(a, b, c);}); +} +// poplar::Graph::addCodelets(std::stringstream &, std::string, poplar::CodeletFileType, std::string)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, std::stringstream & a) {return cl.addCodelets(a);}); +JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, std::stringstream & a, std::string b) {return cl.addCodelets(a, b);}); +JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, std::stringstream & a, std::string b, poplar::CodeletFileType c) {return cl.addCodelets(a, b, c);}); +JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, std::stringstream & a, std::string b, poplar::CodeletFileType c, std::string d) {return cl.addCodelets(a, b, c, d);}); +} +// poplar::Graph::ConnectionDesc::ConnectionDesc(std::string, poplar::Tensor)__CXXConstructor +{ using namespace poplar; +JLGraphConnectionDesc.constructor(); +} +// poplar::Graph::ConnectionDesc::ConnectionDesc(std::string, ArrayRef)__CXXConstructor +{ using namespace poplar; +JLGraphConnectionDesc.constructor>(); +} +// poplar::Graph::addVertex(poplar::ComputeSet, std::string)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphAddVertex", [](poplar::Graph& cl, poplar::ComputeSet a, std::string b) {return cl.addVertex(a, b);}); +} +// poplar::Graph::addVertex(poplar::ComputeSet, std::string, ArrayRef)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphAddVertex", [](poplar::Graph& cl, poplar::ComputeSet a, std::string b, ArrayRef c) {return cl.addVertex(a, b, c);}); +} +// poplar::Graph::addExternalExchangeVertex(poplar::ComputeSet, std::string, unsigned int, bool, bool)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphAddExternalExchangeVertex", [](poplar::Graph& cl, poplar::ComputeSet a, std::string b, unsigned int c, bool d, bool e) {return cl.addExternalExchangeVertex(a, b, c, d, e);}); +} +// poplar::Graph::addVariable(const poplar::Type &, ArrayRef, const poplar::DebugContext &)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphAddVariable", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b) {return cl.addVariable(a, jlcxxToPoplar(b));}); +JLGraph.method("GraphAddVariable", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, std::string c) {return cl.addVariable(a, jlcxxToPoplar(b), c);}); +} +// poplar::Graph::addVariable(const poplar::Type &, const poplar::Tensor &, ArrayRef, const poplar::DebugContext &)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphAddVariable", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c) {return cl.addVariable(a, b, jlcxxToPoplar(c));}); +JLGraph.method("GraphAddVariable", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, std::string d) {return cl.addVariable(a, b, jlcxxToPoplar(c), d);}); +} +// poplar::Graph::addVariable(const poplar::Type &, ArrayRef, poplar::VariableMappingMethod, const poplar::DebugContext &)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphAddVariable", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, poplar::VariableMappingMethod c) {return cl.addVariable(a, jlcxxToPoplar(b), c);}); +JLGraph.method("GraphAddVariable", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, poplar::VariableMappingMethod c, std::string d) {return cl.addVariable(a, jlcxxToPoplar(b), c, d);}); +} +// poplar::Graph::addVariable(const poplar::Type &, const poplar::Tensor &, ArrayRef, poplar::VariableMappingMethod, const poplar::DebugContext &)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphAddVariable", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, poplar::VariableMappingMethod d) {return cl.addVariable(a, b, jlcxxToPoplar(c), d);}); +JLGraph.method("GraphAddVariable", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, poplar::VariableMappingMethod d, std::string e) {return cl.addVariable(a, b, jlcxxToPoplar(c), d, e);}); +} +// poplar::Graph::addExternalVariable(const poplar::Type &, ArrayRef, std::string, const poplar::DebugContext &)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphAddExternalVariable", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, std::string c) {return cl.addExternalVariable(a, jlcxxToPoplar(b), c);}); +JLGraph.method("GraphAddExternalVariable", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, std::string c, std::string d) {return cl.addExternalVariable(a, jlcxxToPoplar(b), c, d);}); +} +// poplar::Graph::addConstant(const poplar::Type &, const poplar::Tensor &, ArrayRef, ArrayRef, const poplar::DebugContext &)__FunctionTemplate +{ using namespace poplar; +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d));}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d, std::string e) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d), e);}); +}{ using namespace poplar; +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d));}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d, std::string e) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d), e);}); +}{ using namespace poplar; +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d));}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d, std::string e) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d), e);}); +}{ using namespace poplar; +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d));}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d, std::string e) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d), e);}); +}{ using namespace poplar; +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d));}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d, std::string e) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d), e);}); +} +// poplar::Graph::addConstant(const poplar::Type &, ArrayRef, ArrayRef, const poplar::DebugContext &)__FunctionTemplate +{ using namespace poplar; +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c));}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c, std::string d) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c), d);}); +}{ using namespace poplar; +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c));}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c, std::string d) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c), d);}); +}{ using namespace poplar; +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c));}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c, std::string d) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c), d);}); +}{ using namespace poplar; +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c));}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c, std::string d) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c), d);}); +}{ using namespace poplar; +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c));}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c, std::string d) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c), d);}); +} +// poplar::Graph::addConstant(const poplar::Type &, ArrayRef, const void *, const poplar::TypeTraits &, bool, const poplar::DebugContext &)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, const void * c, const poplar::TypeTraits & d, bool e) {return cl.addConstant(a, jlcxxToPoplar(b), c, d, e);}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, const void * c, const poplar::TypeTraits & d, bool e, std::string f) {return cl.addConstant(a, jlcxxToPoplar(b), c, d, e, f);}); +} +// poplar::Graph::addConstant(const poplar::Type &, const poplar::Tensor &, ArrayRef, const void *, const poplar::TypeTraits &, bool, const poplar::DebugContext &)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, const void * d, const poplar::TypeTraits & e, bool f) {return cl.addConstant(a, b, jlcxxToPoplar(c), d, e, f);}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, const void * d, const poplar::TypeTraits & e, bool f, std::string g) {return cl.addConstant(a, b, jlcxxToPoplar(c), d, e, f, g);}); +} +// poplar::Graph::addConstantHalf(const poplar::Type &, ArrayRef, uint16_t, const poplar::DebugContext &)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphAddConstantHalf", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, uint16_t c) {return cl.addConstantHalf(a, jlcxxToPoplar(b), c);}); +JLGraph.method("GraphAddConstantHalf", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, uint16_t c, std::string d) {return cl.addConstantHalf(a, jlcxxToPoplar(b), c, d);}); +} +// poplar::Graph::addConstantHalf(const poplar::Type &, ArrayRef, const uint16_t *, const poplar::DebugContext &)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphAddConstantHalf", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, const uint16_t * c) {return cl.addConstantHalf(a, jlcxxToPoplar(b), c);}); +JLGraph.method("GraphAddConstantHalf", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, const uint16_t * c, std::string d) {return cl.addConstantHalf(a, jlcxxToPoplar(b), c, d);}); +} +// poplar::Graph::clone(const poplar::Type &, const poplar::Tensor &, const poplar::DebugContext &, poplar::TensorCloneMethod)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphClone", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b) {return cl.clone(a, b);}); +JLGraph.method("GraphClone", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, std::string c) {return cl.clone(a, b, c);}); +JLGraph.method("GraphClone", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, std::string c, poplar::TensorCloneMethod d) {return cl.clone(a, b, c, d);}); +} +// poplar::Graph::clone(const poplar::Type &, const poplar::Tensor &, const poplar::Tensor &, const poplar::DebugContext &, poplar::TensorCloneMethod)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphClone", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, const poplar::Tensor & c) {return cl.clone(a, b, c);}); +JLGraph.method("GraphClone", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, const poplar::Tensor & c, std::string d) {return cl.clone(a, b, c, d);}); +JLGraph.method("GraphClone", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, const poplar::Tensor & c, std::string d, poplar::TensorCloneMethod e) {return cl.clone(a, b, c, d, e);}); +} +// poplar::Graph::cloneN(const poplar::Type &, const poplar::Tensor &, std::size_t, const poplar::DebugContext &, poplar::TensorCloneMethod, poplar::TensorCloneDuplicationMethod)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, std::size_t c) {return cl.cloneN(a, b, c);}); +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, std::size_t c, std::string d) {return cl.cloneN(a, b, c, d);}); +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, std::size_t c, std::string d, poplar::TensorCloneMethod e) {return cl.cloneN(a, b, c, d, e);}); +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, std::size_t c, std::string d, poplar::TensorCloneMethod e, poplar::TensorCloneDuplicationMethod f) {return cl.cloneN(a, b, c, d, e, f);}); +} +// poplar::Graph::cloneN(const poplar::Type &, const poplar::Tensor &, const poplar::Tensor &, std::size_t, const poplar::DebugContext &, poplar::TensorCloneMethod, poplar::TensorCloneDuplicationMethod)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, const poplar::Tensor & c, std::size_t d) {return cl.cloneN(a, b, c, d);}); +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, const poplar::Tensor & c, std::size_t d, std::string e) {return cl.cloneN(a, b, c, d, e);}); +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, const poplar::Tensor & c, std::size_t d, std::string e, poplar::TensorCloneMethod f) {return cl.cloneN(a, b, c, d, e, f);}); +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, const poplar::Tensor & c, std::size_t d, std::string e, poplar::TensorCloneMethod f, poplar::TensorCloneDuplicationMethod g) {return cl.cloneN(a, b, c, d, e, f, g);}); +} +// poplar::Graph::clone(const poplar::Tensor &, const poplar::DebugContext &, poplar::TensorCloneMethod)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphClone", [](poplar::Graph& cl, const poplar::Tensor & a) {return cl.clone(a);}); +JLGraph.method("GraphClone", [](poplar::Graph& cl, const poplar::Tensor & a, std::string b) {return cl.clone(a, b);}); +JLGraph.method("GraphClone", [](poplar::Graph& cl, const poplar::Tensor & a, std::string b, poplar::TensorCloneMethod c) {return cl.clone(a, b, c);}); +} +// poplar::Graph::clone(const poplar::Tensor &, const poplar::Tensor &, const poplar::DebugContext &, poplar::TensorCloneMethod)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphClone", [](poplar::Graph& cl, const poplar::Tensor & a, const poplar::Tensor & b) {return cl.clone(a, b);}); +JLGraph.method("GraphClone", [](poplar::Graph& cl, const poplar::Tensor & a, const poplar::Tensor & b, std::string c) {return cl.clone(a, b, c);}); +JLGraph.method("GraphClone", [](poplar::Graph& cl, const poplar::Tensor & a, const poplar::Tensor & b, std::string c, poplar::TensorCloneMethod d) {return cl.clone(a, b, c, d);}); +} +// poplar::Graph::cloneN(const poplar::Tensor &, std::size_t, const poplar::DebugContext &, poplar::TensorCloneMethod, poplar::TensorCloneDuplicationMethod)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Tensor & a, std::size_t b) {return cl.cloneN(a, b);}); +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Tensor & a, std::size_t b, std::string c) {return cl.cloneN(a, b, c);}); +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Tensor & a, std::size_t b, std::string c, poplar::TensorCloneMethod d) {return cl.cloneN(a, b, c, d);}); +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Tensor & a, std::size_t b, std::string c, poplar::TensorCloneMethod d, poplar::TensorCloneDuplicationMethod e) {return cl.cloneN(a, b, c, d, e);}); +} +// poplar::Graph::cloneN(const poplar::Tensor &, const poplar::Tensor &, std::size_t, const poplar::DebugContext &, poplar::TensorCloneMethod, poplar::TensorCloneDuplicationMethod)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Tensor & a, const poplar::Tensor & b, std::size_t c) {return cl.cloneN(a, b, c);}); +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Tensor & a, const poplar::Tensor & b, std::size_t c, std::string d) {return cl.cloneN(a, b, c, d);}); +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Tensor & a, const poplar::Tensor & b, std::size_t c, std::string d, poplar::TensorCloneMethod e) {return cl.cloneN(a, b, c, d, e);}); +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Tensor & a, const poplar::Tensor & b, std::size_t c, std::string d, poplar::TensorCloneMethod e, poplar::TensorCloneDuplicationMethod f) {return cl.cloneN(a, b, c, d, e, f);}); +} +// poplar::Graph::connect(poplar::FieldRef, const poplar::Tensor &)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphConnect", [](poplar::Graph& cl, poplar::FieldRef a, const poplar::Tensor & b) {return cl.connect(a, b);}); +} +// poplar::Graph::connect(poplar::FieldRef, T, typename std::enable_if()>::type *)__FunctionTemplate +{ using namespace poplar; +JLGraph.method("GraphConnect", [](poplar::Graph& cl, poplar::FieldRef a, jlcxx::StrictlyTypedNumber b) {return cl.connect(a, b.value);}); +}{ using namespace poplar; +JLGraph.method("GraphConnect", [](poplar::Graph& cl, poplar::FieldRef a, jlcxx::StrictlyTypedNumber b) {return cl.connect(a, b.value);}); +}{ using namespace poplar; +JLGraph.method("GraphConnect", [](poplar::Graph& cl, poplar::FieldRef a, jlcxx::StrictlyTypedNumber b) {return cl.connect(a, b.value);}); +}{ using namespace poplar; +JLGraph.method("GraphConnect", [](poplar::Graph& cl, poplar::FieldRef a, jlcxx::StrictlyTypedNumber b) {return cl.connect(a, b.value);}); +}{ using namespace poplar; +JLGraph.method("GraphConnect", [](poplar::Graph& cl, poplar::FieldRef a, jlcxx::StrictlyTypedNumber b) {return cl.connect(a, b.value);}); +} +// poplar::Graph::connect(poplar::FieldRef, ArrayRef)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphConnect", [](poplar::Graph& cl, poplar::FieldRef a, ArrayRef b) {return cl.connect(a, b);}); +} +// poplar::Graph::setPerfEstimate(const poplar::VertexRef &, std::uint64_t, std::uint64_t)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphSetPerfEstimate", [](poplar::Graph& cl, const poplar::VertexRef & a, std::uint64_t b) {return cl.setPerfEstimate(a, b);}); +JLGraph.method("GraphSetPerfEstimate", [](poplar::Graph& cl, const poplar::VertexRef & a, std::uint64_t b, std::uint64_t c) {return cl.setPerfEstimate(a, b, c);}); +} +// poplar::Graph::setPerfEstimate(const poplar::VertexRef &, const poplar::VertexPerfEstimate &)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphSetPerfEstimate", [](poplar::Graph& cl, const poplar::VertexRef & a, const poplar::VertexPerfEstimate & b) {return cl.setPerfEstimate(a, b);}); +} +// poplar::Graph::getPerfEstimate(const poplar::VertexRef &)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphGetPerfEstimate", [](poplar::Graph& cl, const poplar::VertexRef & a) {return cl.getPerfEstimate(a);}); +} +// poplar::Graph::registerPerfEstimator(std::string, poplar::PerfEstimateFunc)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphRegisterPerfEstimator", [](poplar::Graph& cl, std::string a, poplar::PerfEstimateFunc b) {return cl.registerPerfEstimator(a, b);}); +} +// poplar::Graph::getNumVertices()__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphGetNumVertices", [](poplar::Graph& cl) {return cl.getNumVertices();}); +} +// poplar::Graph::addComputeSet(const poplar::DebugContext &)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphAddComputeSet", [](poplar::Graph& cl) {return cl.addComputeSet();}); +JLGraph.method("GraphAddComputeSet", [](poplar::Graph& cl, std::string a) {return cl.addComputeSet(a);}); +} +// poplar::Graph::setFieldSize(poplar::FieldRef, std::size_t)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphSetFieldSize", [](poplar::Graph& cl, poplar::FieldRef a, std::size_t b) {return cl.setFieldSize(a, b);}); +} +// poplar::Graph::getFieldSize(poplar::FieldRef)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphGetFieldSize", [](poplar::Graph& cl, poplar::FieldRef a) {return cl.getFieldSize(a);}); +} +// poplar::Graph::getMaxFieldDim(std::string, std::string, unsigned int)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphGetMaxFieldDim", [](poplar::Graph& cl, std::string a, std::string b, unsigned int c) {return cl.getMaxFieldDim(a, b, c);}); +} +// poplar::Graph::getMaxVertexFieldValue(std::string, std::string)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphGetMaxVertexFieldValue", [](poplar::Graph& cl, std::string a, std::string b) {return cl.getMaxVertexFieldValue(a, b);}); +} +// poplar::Graph::setInitialValueHalf(poplar::FieldRef, uint16_t)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphSetInitialValueHalf", [](poplar::Graph& cl, poplar::FieldRef a, uint16_t b) {return cl.setInitialValueHalf(a, b);}); +} +// poplar::Graph::setInitialValue(poplar::FieldRef, ArrayRef)__FunctionTemplate +{ using namespace poplar; +JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, poplar::FieldRef a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); +}{ using namespace poplar; +JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, poplar::FieldRef a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); +}{ using namespace poplar; +JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, poplar::FieldRef a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); +}{ using namespace poplar; +JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, poplar::FieldRef a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); +}{ using namespace poplar; +JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, poplar::FieldRef a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); +} +// poplar::Graph::setInitialValueHalf(poplar::FieldRef, ArrayRef)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphSetInitialValueHalf", [](poplar::Graph& cl, poplar::FieldRef a, jlcxx::ArrayRef b) {return cl.setInitialValueHalf(a, jlcxxToPoplar(b));}); +} +// poplar::Graph::setInitialValue(const poplar::Tensor &, const std::map &)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, const poplar::Tensor & a, const std::map & b) {return cl.setInitialValue(a, b);}); +} +// poplar::Graph::setInitialValue(const poplar::Tensor &, ArrayRef)__FunctionTemplate +{ using namespace poplar; +JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, const poplar::Tensor & a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); +}{ using namespace poplar; +JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, const poplar::Tensor & a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); +}{ using namespace poplar; +JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, const poplar::Tensor & a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); +}{ using namespace poplar; +JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, const poplar::Tensor & a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); +}{ using namespace poplar; +JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, const poplar::Tensor & a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); +} +// poplar::Graph::setInitialValueHalf(const poplar::Tensor &, uint16_t)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphSetInitialValueHalf", [](poplar::Graph& cl, const poplar::Tensor & a, uint16_t b) {return cl.setInitialValueHalf(a, b);}); +} +// poplar::Graph::setInitialValueHalf(const poplar::Tensor &, ArrayRef)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphSetInitialValueHalf", [](poplar::Graph& cl, const poplar::Tensor & a, jlcxx::ArrayRef b) {return cl.setInitialValueHalf(a, jlcxxToPoplar(b));}); +} +// poplar::Graph::createHostWrite(std::string, const poplar::Tensor &, bool)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphCreateHostWrite", [](poplar::Graph& cl, std::string a, const poplar::Tensor & b) {return cl.createHostWrite(a, b);}); +JLGraph.method("GraphCreateHostWrite", [](poplar::Graph& cl, std::string a, const poplar::Tensor & b, bool c) {return cl.createHostWrite(a, b, c);}); +} +// poplar::Graph::createHostRead(std::string, const poplar::Tensor &, bool)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphCreateHostRead", [](poplar::Graph& cl, std::string a, const poplar::Tensor & b) {return cl.createHostRead(a, b);}); +JLGraph.method("GraphCreateHostRead", [](poplar::Graph& cl, std::string a, const poplar::Tensor & b, bool c) {return cl.createHostRead(a, b, c);}); +} +// poplar::Graph::addHostToDeviceFIFO(std::string, const poplar::Type &, std::size_t, poplar::ReplicatedStreamMode, const poplar::OptionFlags &)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphAddHostToDeviceFIFO", [](poplar::Graph& cl, std::string a, const poplar::Type & b, std::size_t c) {return cl.addHostToDeviceFIFO(a, b, c);}); +JLGraph.method("GraphAddHostToDeviceFIFO", [](poplar::Graph& cl, std::string a, const poplar::Type & b, std::size_t c, poplar::ReplicatedStreamMode d) {return cl.addHostToDeviceFIFO(a, b, c, d);}); +JLGraph.method("GraphAddHostToDeviceFIFO", [](poplar::Graph& cl, std::string a, const poplar::Type & b, std::size_t c, poplar::ReplicatedStreamMode d, const poplar::OptionFlags & e) {return cl.addHostToDeviceFIFO(a, b, c, d, e);}); +} +// poplar::Graph::addDeviceToHostFIFO(std::string, const poplar::Type &, std::size_t, const poplar::OptionFlags &)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphAddDeviceToHostFIFO", [](poplar::Graph& cl, std::string a, const poplar::Type & b, std::size_t c) {return cl.addDeviceToHostFIFO(a, b, c);}); +JLGraph.method("GraphAddDeviceToHostFIFO", [](poplar::Graph& cl, std::string a, const poplar::Type & b, std::size_t c, const poplar::OptionFlags & d) {return cl.addDeviceToHostFIFO(a, b, c, d);}); +} +// poplar::Graph::addRemoteBuffer(std::string, const poplar::Type &, std::size_t, std::size_t, bool, bool)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphAddRemoteBuffer", [](poplar::Graph& cl, std::string a, const poplar::Type & b, std::size_t c) {return cl.addRemoteBuffer(a, b, c);}); +JLGraph.method("GraphAddRemoteBuffer", [](poplar::Graph& cl, std::string a, const poplar::Type & b, std::size_t c, std::size_t d) {return cl.addRemoteBuffer(a, b, c, d);}); +JLGraph.method("GraphAddRemoteBuffer", [](poplar::Graph& cl, std::string a, const poplar::Type & b, std::size_t c, std::size_t d, bool e) {return cl.addRemoteBuffer(a, b, c, d, e);}); +JLGraph.method("GraphAddRemoteBuffer", [](poplar::Graph& cl, std::string a, const poplar::Type & b, std::size_t c, std::size_t d, bool e, bool f) {return cl.addRemoteBuffer(a, b, c, d, e, f);}); +} +// poplar::Graph::setTileMapping(poplar::VertexRef, unsigned int)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphSetTileMapping", [](poplar::Graph& cl, poplar::VertexRef a, unsigned int b) {return cl.setTileMapping(a, b);}); +} +// poplar::Graph::setTileMapping(const poplar::Tensor &, unsigned int)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphSetTileMapping", [](poplar::Graph& cl, const poplar::Tensor & a, unsigned int b) {return cl.setTileMapping(a, b);}); +} +// poplar::Graph::getTileMapping(const poplar::Tensor &, bool, bool)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphGetTileMapping", [](poplar::Graph& cl, const poplar::Tensor & a) {return cl.getTileMapping(a);}); +JLGraph.method("GraphGetTileMapping", [](poplar::Graph& cl, const poplar::Tensor & a, bool b) {return cl.getTileMapping(a, b);}); +JLGraph.method("GraphGetTileMapping", [](poplar::Graph& cl, const poplar::Tensor & a, bool b, bool c) {return cl.getTileMapping(a, b, c);}); +} +// poplar::Graph::getTileMapping(const poplar::Tensor &, bool *, bool)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphGetTileMapping", [](poplar::Graph& cl, const poplar::Tensor & a, bool * b) {return cl.getTileMapping(a, b);}); +JLGraph.method("GraphGetTileMapping", [](poplar::Graph& cl, const poplar::Tensor & a, bool * b, bool c) {return cl.getTileMapping(a, b, c);}); +} +// poplar::Graph::getVariableTileMapping(const poplar::Tensor &)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphGetVariableTileMapping", [](poplar::Graph& cl, const poplar::Tensor & a) {return cl.getVariableTileMapping(a);}); +} +// poplar::Graph::setTileMapping(const poplar::Tensor &, const poplar::Graph::TileToTensorMapping &)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphSetTileMapping", [](poplar::Graph& cl, const poplar::Tensor & a, const poplar::Graph::TileToTensorMapping & b) {return cl.setTileMapping(a, b);}); +} +// poplar::Graph::getVariable(poplar::VariableRef)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphGetVariable", [](poplar::Graph& cl, poplar::VariableRef a) {return cl.getVariable(a);}); +} +// poplar::Graph::isConstant(poplar::VariableRef)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphIsConstant", [](poplar::Graph& cl, poplar::VariableRef a) {return cl.isConstant(a);}); +} +// poplar::Graph::getSortedContiguousRegions(const poplar::Tensor &, ArrayRef, bool, std::vector *)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphGetSortedContiguousRegions", [](poplar::Graph& cl, const poplar::Tensor & a, ArrayRef b) {return cl.getSortedContiguousRegions(a, b);}); +JLGraph.method("GraphGetSortedContiguousRegions", [](poplar::Graph& cl, const poplar::Tensor & a, ArrayRef b, bool c) {return cl.getSortedContiguousRegions(a, b, c);}); +JLGraph.method("GraphGetSortedContiguousRegions", [](poplar::Graph& cl, const poplar::Tensor & a, ArrayRef b, bool c, std::vector * d) {return cl.getSortedContiguousRegions(a, b, c, d);}); +} +// poplar::Graph::reorderToSimplify(poplar::Tensor *, ArrayRef, bool)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphReorderToSimplify", [](poplar::Graph& cl, poplar::Tensor * a, ArrayRef b) {return cl.reorderToSimplify(a, b);}); +JLGraph.method("GraphReorderToSimplify", [](poplar::Graph& cl, poplar::Tensor * a, ArrayRef b, bool c) {return cl.reorderToSimplify(a, b, c);}); +} +// poplar::Graph::getSimplifyingRearranger(const poplar::Tensor &)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphGetSimplifyingRearranger", [](poplar::Graph& cl, const poplar::Tensor & a) {return cl.getSimplifyingRearranger(a);}); +} +// poplar::Graph::findUnbroadcastTensor(const poplar::Tensor &)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphFindUnbroadcastTensor", [](poplar::Graph& cl, const poplar::Tensor & a) {return cl.findUnbroadcastTensor(a);}); +} +// poplar::Graph::createVirtualGraph(unsigned int)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphCreateVirtualGraph", [](poplar::Graph& cl, unsigned int a) {return cl.createVirtualGraph(a);}); +} +// poplar::Graph::createVirtualGraph(unsigned int, unsigned int)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphCreateVirtualGraph", [](poplar::Graph& cl, unsigned int a, unsigned int b) {return cl.createVirtualGraph(a, b);}); +} +// poplar::Graph::createVirtualGraph(const std::vector &)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphCreateVirtualGraph", [](poplar::Graph& cl, const std::vector & a) {return cl.createVirtualGraph(a);}); +} +// poplar::Graph::getTopLevelGraph()__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphGetTopLevelGraph", [](poplar::Graph& cl) {return cl.getTopLevelGraph();}); +} +// poplar::Graph::getReplicationFactor()__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphGetReplicationFactor", [](poplar::Graph& cl) {return cl.getReplicationFactor();}); +} +// poplar::Graph::addReplicationIndexConstant(const poplar::DebugContext &)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphAddReplicationIndexConstant", [](poplar::Graph& cl) {return cl.addReplicationIndexConstant();}); +JLGraph.method("GraphAddReplicationIndexConstant", [](poplar::Graph& cl, std::string a) {return cl.addReplicationIndexConstant(a);}); +} +// poplar::Graph::addFunction(const program::Program &)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphAddFunction", [](poplar::Graph& cl, const program::Program & a) {return cl.addFunction(a);}); +} +// poplar::Graph::addFunctionBuffer(const poplar::Function &, poplar::FunctionBufferMappingType)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphAddFunctionBuffer", [](poplar::Graph& cl, const poplar::Function & a, poplar::FunctionBufferMappingType b) {return cl.addFunctionBuffer(a, b);}); +} +// poplar::Graph::addHostFunction(std::string, ArrayRef, ArrayRef)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphAddHostFunction", [](poplar::Graph& cl, std::string a, ArrayRef b, ArrayRef c) {return cl.addHostFunction(a, b, c);}); +} +// poplar::Graph::convertTileToTopLevelGraphTile(unsigned int)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphConvertTileToTopLevelGraphTile", [](poplar::Graph& cl, unsigned int a) {return cl.convertTileToTopLevelGraphTile(a);}); +} +// poplar::Graph::convertTopLevelGraphTileToTile(unsigned int)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphConvertTopLevelGraphTileToTile", [](poplar::Graph& cl, unsigned int a) {return cl.convertTopLevelGraphTileToTile(a);}); +} +// poplar::Graph::convertVirtualTileToPhysicalTile(unsigned int)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphConvertVirtualTileToPhysicalTile", [](poplar::Graph& cl, unsigned int a) {return cl.convertVirtualTileToPhysicalTile(a);}); +} +// poplar::Graph::convertPhysicalTileToVirtualTile(unsigned int)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphConvertPhysicalTileToVirtualTile", [](poplar::Graph& cl, unsigned int a) {return cl.convertPhysicalTileToVirtualTile(a);}); +} +// poplar::Graph::convertPhysicalTileToVirtualTile(unsigned int, unsigned int)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphConvertPhysicalTileToVirtualTile", [](poplar::Graph& cl, unsigned int a, unsigned int b) {return cl.convertPhysicalTileToVirtualTile(a, b);}); +} +// poplar::Graph::hasCodelet(std::string)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphHasCodelet", [](poplar::Graph& cl, std::string a) {return cl.hasCodelet(a);}); +} +// poplar::RuntimeOptions::RuntimeOptions(const poplar::OptionFlags &)__CXXConstructor +{ using namespace poplar; +JLRuntimeOptions.constructor(); +} +// poplar::RuntimeOptions::RuntimeOptions(const poplar::RuntimeOptions &)__CXXConstructor +{ using namespace poplar; +JLRuntimeOptions.constructor(); +} +// poplar::StreamCallbackBase::Result::Success__EnumConstantDecl +mod.set_const("StreamCallbackBaseResultStreamCallbackBaseSuccess", poplar::StreamCallbackBase::Result::Success); +// poplar::StreamCallbackBase::Result::NotAvailable__EnumConstantDecl +mod.set_const("StreamCallbackBaseResultStreamCallbackBaseNotAvailable", poplar::StreamCallbackBase::Result::NotAvailable); +// poplar::StreamCallbackBase::complete()__CXXMethod +{ using namespace poplar; +JLStreamCallbackBase.method("StreamCallbackBaseComplete", [](poplar::StreamCallbackBase& cl) {return cl.complete();}); +} +// poplar::StreamCallbackBase::invalidatePrefetched()__CXXMethod +{ using namespace poplar; +JLStreamCallbackBase.method("StreamCallbackBaseInvalidatePrefetched", [](poplar::StreamCallbackBase& cl) {return cl.invalidatePrefetched();}); +} +// poplar::StreamCallback::prefetch(void *)__CXXMethod +{ using namespace poplar; +JLStreamCallback.method("StreamCallbackPrefetch", [](poplar::StreamCallback& cl, void * a) {return cl.prefetch(a);}); +} +// poplar::StreamCallback::fetch(void *)__CXXMethod +{ using namespace poplar; +JLStreamCallback.method("StreamCallbackFetch", [](poplar::StreamCallback& cl, void * a) {return cl.fetch(a);}); +} +// poplar::StreamCallbackWithMetadata::getMetadata()__CXXMethod +{ using namespace poplar; +JLStreamCallbackWithMetadata.method("StreamCallbackWithMetadataGetMetadata", [](poplar::StreamCallbackWithMetadata& cl) {return cl.getMetadata();}); +} +// poplar::ResumableStreamCallback::notify()__CXXMethod +{ using namespace poplar; +JLResumableStreamCallback.method("ResumableStreamCallbackNotify", [](poplar::ResumableStreamCallback& cl) {return cl.notify();}); +} +// poplar::ResumableStreamCallback::isAwaiting()__CXXMethod +{ using namespace poplar; +JLResumableStreamCallback.method("ResumableStreamCallbackIsAwaiting", [](poplar::ResumableStreamCallback& cl) {return cl.isAwaiting();}); +} +// poplar::LegacyStreamCallback::prefetch(void *)__CXXMethod +{ using namespace poplar; +JLLegacyStreamCallback.method("LegacyStreamCallbackPrefetch", [](poplar::LegacyStreamCallback& cl, void * a) {return cl.prefetch(a);}); +} +// poplar::LegacyStreamCallback::invalidatePrefetched()__CXXMethod +{ using namespace poplar; +JLLegacyStreamCallback.method("LegacyStreamCallbackInvalidatePrefetched", [](poplar::LegacyStreamCallback& cl) {return cl.invalidatePrefetched();}); +} +// poplar::LegacyStreamCallback::complete()__CXXMethod +{ using namespace poplar; +JLLegacyStreamCallback.method("LegacyStreamCallbackComplete", [](poplar::LegacyStreamCallback& cl) {return cl.complete();}); +} +// poplar::Engine::Engine(const poplar::Graph &, ArrayRef, const poplar::OptionFlags &, poplar::Engine::ProgressFunc, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar; +JLEngine.constructor>(); +JLEngine.constructor, const poplar::OptionFlags &>(); +JLEngine.constructor, const poplar::OptionFlags &, poplar::Engine::ProgressFunc>(); +JLEngine.constructor, const poplar::OptionFlags &, poplar::Engine::ProgressFunc, std::string>(); +} +// poplar::Engine::Engine(const poplar::Graph &, program::Program, const poplar::OptionFlags &, poplar::Engine::ProgressFunc, const poplar::DebugContext &)__CXXConstructor +{ using namespace poplar; +JLEngine.constructor(); +JLEngine.constructor(); +JLEngine.constructor(); +JLEngine.constructor(); +} +// poplar::Engine::prepare(const poplar::Device &)__CXXMethod +{ using namespace poplar; +JLEngine.method("EnginePrepare", [](poplar::Engine& cl, const poplar::Device & a) {return cl.prepare(a);}); +} +// poplar::Engine::prepare(const poplar::Device &, const poplar::RuntimeOptions &)__CXXMethod +{ using namespace poplar; +JLEngine.method("EnginePrepare", [](poplar::Engine& cl, const poplar::Device & a, const poplar::RuntimeOptions & b) {return cl.prepare(a, b);}); +} +// poplar::Engine::deploy()__CXXMethod +{ using namespace poplar; +JLEngine.method("EngineDeploy", [](poplar::Engine& cl) {return cl.deploy();}); +} +// poplar::Engine::load(const poplar::Device &)__CXXMethod +{ using namespace poplar; +JLEngine.method("EngineLoad", [](poplar::Engine& cl, const poplar::Device & a) {return cl.load(a);}); +} +// poplar::Engine::run(unsigned int, const std::string &)__CXXMethod +{ using namespace poplar; +JLEngine.method("EngineRun", [](poplar::Engine& cl) {return cl.run();}); +JLEngine.method("EngineRun", [](poplar::Engine& cl, unsigned int a) {return cl.run(a);}); +JLEngine.method("EngineRun", [](poplar::Engine& cl, unsigned int a, const std::string & b) {return cl.run(a, b);}); +} +// poplar::Engine::stop()__CXXMethod +{ using namespace poplar; +JLEngine.method("EngineStop", [](poplar::Engine& cl) {return cl.stop();}); +} +// poplar::Engine::run(unsigned int, const std::string &, const poplar::RuntimeOptions &)__CXXMethod +{ using namespace poplar; +JLEngine.method("EngineRun", [](poplar::Engine& cl, unsigned int a, const std::string & b, const poplar::RuntimeOptions & c) {return cl.run(a, b, c);}); +} +// poplar::Engine::loadAndRun(const poplar::Device &, unsigned int)__CXXMethod +{ using namespace poplar; +JLEngine.method("EngineLoadAndRun", [](poplar::Engine& cl, const poplar::Device & a) {return cl.loadAndRun(a);}); +JLEngine.method("EngineLoadAndRun", [](poplar::Engine& cl, const poplar::Device & a, unsigned int b) {return cl.loadAndRun(a, b);}); +} +// poplar::Engine::getTimeStamp()__CXXMethod +{ using namespace poplar; +JLEngine.method("EngineGetTimeStamp", [](poplar::Engine& cl) {return cl.getTimeStamp();}); +} +// poplar::Engine::reportTiming(const poplar::Engine::TimerTimePoint &, const poplar::Engine::TimerTimePoint &)__CXXMethod +{ using namespace poplar; +JLEngine.method("EngineReportTiming", [](poplar::Engine& cl, const poplar::Engine::TimerTimePoint & a, const poplar::Engine::TimerTimePoint & b) {return cl.reportTiming(a, b);}); +} +// poplar::Engine::resetExecutionProfile()__CXXMethod +{ using namespace poplar; +JLEngine.method("EngineResetExecutionProfile", [](poplar::Engine& cl) {return cl.resetExecutionProfile();}); +} +// poplar::Engine::disableExecutionProfiling()__CXXMethod +{ using namespace poplar; +JLEngine.method("EngineDisableExecutionProfiling", [](poplar::Engine& cl) {return cl.disableExecutionProfiling();}); +} +// poplar::Engine::enableExecutionProfiling()__CXXMethod +{ using namespace poplar; +JLEngine.method("EngineEnableExecutionProfiling", [](poplar::Engine& cl) {return cl.enableExecutionProfiling();}); +} +// poplar::Engine::readTensor(std::string, void *, void *)__CXXMethod +{ using namespace poplar; +JLEngine.method("EngineReadTensor", [](poplar::Engine& cl, std::string a, void * b, void * c) {return cl.readTensor(a, b, c);}); +} +// poplar::Engine::readTensor(std::string, gccs::ArrayRef)__FunctionTemplate +{ using namespace poplar; +JLEngine.method("EngineReadTensor", [](poplar::Engine& cl, std::string a, gccs::ArrayRef b) {return cl.readTensor(a, b);}); +}{ using namespace poplar; +JLEngine.method("EngineReadTensor", [](poplar::Engine& cl, std::string a, gccs::ArrayRef b) {return cl.readTensor(a, b);}); +}{ using namespace poplar; +JLEngine.method("EngineReadTensor", [](poplar::Engine& cl, std::string a, gccs::ArrayRef b) {return cl.readTensor(a, b);}); +}{ using namespace poplar; +JLEngine.method("EngineReadTensor", [](poplar::Engine& cl, std::string a, gccs::ArrayRef b) {return cl.readTensor(a, b);}); +} +// poplar::Engine::writeTensor(std::string, const void *, const void *)__CXXMethod +{ using namespace poplar; +JLEngine.method("EngineWriteTensor", [](poplar::Engine& cl, std::string a, const void * b, const void * c) {return cl.writeTensor(a, b, c);}); +} +// poplar::Engine::writeTensor(std::string, ArrayRef)__FunctionTemplate +{ using namespace poplar; +JLEngine.method("EngineWriteTensor", [](poplar::Engine& cl, std::string a, jlcxx::ArrayRef b) {return cl.writeTensor(a, jlcxxToPoplar(b));}); +}{ using namespace poplar; +JLEngine.method("EngineWriteTensor", [](poplar::Engine& cl, std::string a, jlcxx::ArrayRef b) {return cl.writeTensor(a, jlcxxToPoplar(b));}); +}{ using namespace poplar; +JLEngine.method("EngineWriteTensor", [](poplar::Engine& cl, std::string a, jlcxx::ArrayRef b) {return cl.writeTensor(a, jlcxxToPoplar(b));}); +}{ using namespace poplar; +JLEngine.method("EngineWriteTensor", [](poplar::Engine& cl, std::string a, jlcxx::ArrayRef b) {return cl.writeTensor(a, jlcxxToPoplar(b));}); +} +// poplar::Engine::connectStream(std::string, void *, void *)__CXXMethod +{ using namespace poplar; +JLEngine.method("EngineConnectStream", [](poplar::Engine& cl, std::string a, void * b, void * c) {return cl.connectStream(a, b, c);}); +} +// poplar::Engine::connectStream(std::string, const gccs::ArrayRef &)__FunctionTemplate +{ using namespace poplar; +JLEngine.method("EngineConnectStream", [](poplar::Engine& cl, std::string a, const gccs::ArrayRef & b) {return cl.connectStream(a, b);}); +}{ using namespace poplar; +JLEngine.method("EngineConnectStream", [](poplar::Engine& cl, std::string a, const gccs::ArrayRef & b) {return cl.connectStream(a, b);}); +}{ using namespace poplar; +JLEngine.method("EngineConnectStream", [](poplar::Engine& cl, std::string a, const gccs::ArrayRef & b) {return cl.connectStream(a, b);}); +}{ using namespace poplar; +JLEngine.method("EngineConnectStream", [](poplar::Engine& cl, std::string a, const gccs::ArrayRef & b) {return cl.connectStream(a, b);}); +} +// poplar::Engine::connectStream(std::string, void *)__CXXMethod +{ using namespace poplar; +JLEngine.method("EngineConnectStream", [](poplar::Engine& cl, std::string a, void * b) {return cl.connectStream(a, b);}); +} +// poplar::Engine::copyFromRemoteBuffer(std::string, void *, uint64_t, unsigned int)__CXXMethod +{ using namespace poplar; +JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, std::string a, void * b, uint64_t c) {return cl.copyFromRemoteBuffer(a, b, c);}); +JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, std::string a, void * b, uint64_t c, unsigned int d) {return cl.copyFromRemoteBuffer(a, b, c, d);}); +} +// poplar::Engine::copyFromRemoteBuffer(std::string, gccs::ArrayRef, uint64_t, unsigned int)__FunctionTemplate +{ using namespace poplar; +JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, std::string a, gccs::ArrayRef b, uint64_t c) {return cl.copyFromRemoteBuffer(a, b, c);}); +JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, std::string a, gccs::ArrayRef b, uint64_t c, unsigned int d) {return cl.copyFromRemoteBuffer(a, b, c, d);}); +}{ using namespace poplar; +JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, std::string a, gccs::ArrayRef b, uint64_t c) {return cl.copyFromRemoteBuffer(a, b, c);}); +JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, std::string a, gccs::ArrayRef b, uint64_t c, unsigned int d) {return cl.copyFromRemoteBuffer(a, b, c, d);}); +}{ using namespace poplar; +JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, std::string a, gccs::ArrayRef b, uint64_t c) {return cl.copyFromRemoteBuffer(a, b, c);}); +JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, std::string a, gccs::ArrayRef b, uint64_t c, unsigned int d) {return cl.copyFromRemoteBuffer(a, b, c, d);}); +}{ using namespace poplar; +JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, std::string a, gccs::ArrayRef b, uint64_t c) {return cl.copyFromRemoteBuffer(a, b, c);}); +JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, std::string a, gccs::ArrayRef b, uint64_t c, unsigned int d) {return cl.copyFromRemoteBuffer(a, b, c, d);}); +} +// poplar::Engine::copyToRemoteBuffer(void *, std::string, uint64_t, unsigned int)__CXXMethod +{ using namespace poplar; +JLEngine.method("EngineCopyToRemoteBuffer", [](poplar::Engine& cl, void * a, std::string b, uint64_t c) {return cl.copyToRemoteBuffer(a, b, c);}); +JLEngine.method("EngineCopyToRemoteBuffer", [](poplar::Engine& cl, void * a, std::string b, uint64_t c, unsigned int d) {return cl.copyToRemoteBuffer(a, b, c, d);}); +} +// poplar::Engine::listStreams()__CXXMethod +{ using namespace poplar; +JLEngine.method("EngineListStreams", [](poplar::Engine& cl) {return cl.listStreams();}); +} +// poplar::Engine::getEngineOptions()__CXXMethod +{ using namespace poplar; +JLEngine.method("EngineGetEngineOptions", [](poplar::Engine& cl) {return cl.getEngineOptions();}); +} +// poplar::Engine::insertSimulatedError(poplar::ErrorCode, const poplar::ErrorLocation &)__CXXMethod +{ using namespace poplar; +JLEngine.method("EngineInsertSimulatedError", [](poplar::Engine& cl, poplar::ErrorCode a, const poplar::ErrorLocation & b) {return cl.insertSimulatedError(a, b);}); +} +// poplar::Engine::eraseSimulatedError(const poplar::ErrorLocation &)__CXXMethod +{ using namespace poplar; +JLEngine.method("EngineEraseSimulatedError", [](poplar::Engine& cl, const poplar::ErrorLocation & a) {return cl.eraseSimulatedError(a);}); +} +// poplar::Engine::clearSimulatedErrors()__CXXMethod +{ using namespace poplar; +JLEngine.method("EngineClearSimulatedErrors", [](poplar::Engine& cl) {return cl.clearSimulatedErrors();}); +} +// poplar::Engine::getSimulatedErrorLocations(unsigned int, unsigned int)__CXXMethod +{ using namespace poplar; +JLEngine.method("EngineGetSimulatedErrorLocations", [](poplar::Engine& cl, unsigned int a) {return cl.getSimulatedErrorLocations(a);}); +JLEngine.method("EngineGetSimulatedErrorLocations", [](poplar::Engine& cl, unsigned int a, unsigned int b) {return cl.getSimulatedErrorLocations(a, b);}); +} +// poplar::Engine::getSimulatedErrorLocations(std::string, unsigned int)__CXXMethod +{ using namespace poplar; +JLEngine.method("EngineGetSimulatedErrorLocations", [](poplar::Engine& cl, std::string a) {return cl.getSimulatedErrorLocations(a);}); +JLEngine.method("EngineGetSimulatedErrorLocations", [](poplar::Engine& cl, std::string a, unsigned int b) {return cl.getSimulatedErrorLocations(a, b);}); +} +// poplar::compileGraph(const poplar::Graph &, ArrayRef, const poplar::OptionFlags &, poplar::ProgressFunc, const poplar::DebugContext &)__FunctionDecl +{ using namespace poplar; +mod.method("PoplarCompileGraph", [](const poplar::Graph & a, ArrayRef b, const poplar::OptionFlags & c, poplar::ProgressFunc d, std::string e) {return poplar::compileGraph(a, b, c, d, e);} ); } +// poplar::compileModule(const poplar::Graph &, program::Program, const poplar::OptionFlags &, poplar::ProgressFunc, const poplar::DebugContext &)__FunctionDecl +{ using namespace poplar; +mod.method("PoplarCompileModule", [](const poplar::Graph & a, program::Program b, const poplar::OptionFlags & c, poplar::ProgressFunc d, std::string e) {return poplar::compileModule(a, b, c, d, e);} ); } +// poplar::FloatingPointBehaviour::FloatingPointBehaviour(bool, bool, bool, bool, bool)__CXXConstructor +{ using namespace poplar; +JLFloatingPointBehaviour.constructor(); +} +// poplar::setFloatingPointBehaviour(poplar::Graph &, poplar::program::Sequence &, const poplar::FloatingPointBehaviour &, const poplar::DebugContext &)__FunctionDecl +{ using namespace poplar; +mod.method("PoplarSetFloatingPointBehaviour", [](poplar::Graph & a, poplar::program::Sequence & b, const poplar::FloatingPointBehaviour & c, std::string d) {return poplar::setFloatingPointBehaviour(a, b, c, d);} ); } +// poplar::setFloatingPointBehaviour(poplar::Graph &, poplar::program::Sequence &, const poplar::Tensor &, const poplar::DebugContext &)__FunctionDecl +{ using namespace poplar; +mod.method("PoplarSetFloatingPointBehaviour", [](poplar::Graph & a, poplar::program::Sequence & b, const poplar::Tensor & c, std::string d) {return poplar::setFloatingPointBehaviour(a, b, c, d);} ); } +// poplar::setStochasticRounding(poplar::Graph &, poplar::program::Sequence &, bool, const poplar::DebugContext &)__FunctionDecl +{ using namespace poplar; +mod.method("PoplarSetStochasticRounding", [](poplar::Graph & a, poplar::program::Sequence & b, bool c, std::string d) {return poplar::setStochasticRounding(a, b, c, d);} ); } +// poplar::getAndModifyFloatingPointBehaviour(poplar::Graph &, poplar::program::Sequence &, const poplar::FloatingPointBehaviour &, const poplar::FloatingPointBehaviour &, const poplar::DebugContext &)__FunctionDecl +{ using namespace poplar; +mod.method("PoplarGetAndModifyFloatingPointBehaviour", [](poplar::Graph & a, poplar::program::Sequence & b, const poplar::FloatingPointBehaviour & c, const poplar::FloatingPointBehaviour & d, std::string e) {return poplar::getAndModifyFloatingPointBehaviour(a, b, c, d, e);} ); } +// poplar::IPUModel::IPUModel(const char *)__CXXConstructor +{ using namespace poplar; +JLIPUModel.constructor(); +} +// poplar::IPUModel::RelativeSyncDelayType::AUTO__EnumConstantDecl +mod.set_const("IPUModelRelativeSyncDelayTypeIPUModelAUTO", poplar::IPUModel::RelativeSyncDelayType::AUTO); +// poplar::IPUModel::RelativeSyncDelayType::NO_DELAY__EnumConstantDecl +mod.set_const("IPUModelRelativeSyncDelayTypeIPUModelNO_DELAY", poplar::IPUModel::RelativeSyncDelayType::NO_DELAY); +// poplar::IPUModel::createDevice(poplar::OptionFlags, bool, unsigned int)__CXXMethod +{ using namespace poplar; +JLIPUModel.method("IPUModelCreateDevice", [](poplar::IPUModel& cl) {return cl.createDevice();}); +JLIPUModel.method("IPUModelCreateDevice", [](poplar::IPUModel& cl, poplar::OptionFlags a) {return cl.createDevice(a);}); +JLIPUModel.method("IPUModelCreateDevice", [](poplar::IPUModel& cl, poplar::OptionFlags a, bool b) {return cl.createDevice(a, b);}); +JLIPUModel.method("IPUModelCreateDevice", [](poplar::IPUModel& cl, poplar::OptionFlags a, bool b, unsigned int c) {return cl.createDevice(a, b, c);}); +} +// popops::varianceToInvStdDev(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::Type, const poplar::DebugContext &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsVarianceToInvStdDev", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, const poplar::Type e, std::string f) {return popops::varianceToInvStdDev(a, b, c, d, e, f);} ); } +// popops::varianceToInvStdDev(poplar::Graph &, const poplar::Tensor &, const float, poplar::program::Sequence &, const poplar::Type, const poplar::DebugContext &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsVarianceToInvStdDev", [](poplar::Graph & a, const poplar::Tensor & b, const float c, poplar::program::Sequence & d, const poplar::Type e, std::string f) {return popops::varianceToInvStdDev(a, b, c, d, e, f);} ); } +// popops::invStdDevToVariance(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::Type, const poplar::DebugContext &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsInvStdDevToVariance", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, const poplar::Type e, std::string f) {return popops::invStdDevToVariance(a, b, c, d, e, f);} ); } +// popops::invStdDevToVariance(poplar::Graph &, const poplar::Tensor &, const float, poplar::program::Sequence &, const poplar::Type, const poplar::DebugContext &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsInvStdDevToVariance", [](poplar::Graph & a, const poplar::Tensor & b, const float c, poplar::program::Sequence & d, const poplar::Type e, std::string f) {return popops::invStdDevToVariance(a, b, c, d, e, f);} ); } +// popops::abs(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsAbs", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::abs(a, b, c, d, e);} ); } +// popops::absInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsAbsInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::absInPlace(a, b, c, d, e);} ); } +// popops::absWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsAbsWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::absWithOutput(a, b, c, d, e, f);} ); } +// popops::asin(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsAsin", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::asin(a, b, c, d, e);} ); } +// popops::asinInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsAsinInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::asinInPlace(a, b, c, d, e);} ); } +// popops::asinWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsAsinWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::asinWithOutput(a, b, c, d, e, f);} ); } +// popops::bitwiseNot(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsBitwiseNot", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::bitwiseNot(a, b, c, d, e);} ); } +// popops::bitwiseNotInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsBitwiseNotInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::bitwiseNotInPlace(a, b, c, d, e);} ); } +// popops::bitwiseNotWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsBitwiseNotWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::bitwiseNotWithOutput(a, b, c, d, e, f);} ); } +// popops::cbrt(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsCbrt", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::cbrt(a, b, c, d, e);} ); } +// popops::cbrtInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsCbrtInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::cbrtInPlace(a, b, c, d, e);} ); } +// popops::cbrtWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsCbrtWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::cbrtWithOutput(a, b, c, d, e, f);} ); } +// popops::geluErf(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsGeluErf", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::geluErf(a, b, c, d, e);} ); } +// popops::geluErfInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsGeluErfInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::geluErfInPlace(a, b, c, d, e);} ); } +// popops::geluErfWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsGeluErfWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::geluErfWithOutput(a, b, c, d, e, f);} ); } +// popops::ceil(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsCeil", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::ceil(a, b, c, d, e);} ); } +// popops::ceilInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsCeilInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::ceilInPlace(a, b, c, d, e);} ); } +// popops::ceilWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsCeilWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::ceilWithOutput(a, b, c, d, e, f);} ); } +// popops::countLeadingZeros(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsCountLeadingZeros", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::countLeadingZeros(a, b, c, d, e);} ); } +// popops::countLeadingZerosInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsCountLeadingZerosInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::countLeadingZerosInPlace(a, b, c, d, e);} ); } +// popops::countLeadingZerosWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsCountLeadingZerosWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::countLeadingZerosWithOutput(a, b, c, d, e, f);} ); } +// popops::cos(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsCos", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::cos(a, b, c, d, e);} ); } +// popops::cosInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsCosInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::cosInPlace(a, b, c, d, e);} ); } +// popops::cosWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsCosWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::cosWithOutput(a, b, c, d, e, f);} ); } +// popops::erf(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsErf", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::erf(a, b, c, d, e);} ); } +// popops::erfInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsErfInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::erfInPlace(a, b, c, d, e);} ); } +// popops::erfWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsErfWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::erfWithOutput(a, b, c, d, e, f);} ); } +// popops::exp(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsExp", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::exp(a, b, c, d, e);} ); } +// popops::expInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsExpInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::expInPlace(a, b, c, d, e);} ); } +// popops::expWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsExpWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::expWithOutput(a, b, c, d, e, f);} ); } +// popops::expm1(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsExpm1", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::expm1(a, b, c, d, e);} ); } +// popops::expm1InPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsExpm1InPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::expm1InPlace(a, b, c, d, e);} ); } +// popops::expm1WithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsExpm1WithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::expm1WithOutput(a, b, c, d, e, f);} ); } +// popops::floor(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsFloor", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::floor(a, b, c, d, e);} ); } +// popops::floorInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsFloorInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::floorInPlace(a, b, c, d, e);} ); } +// popops::floorWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsFloorWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::floorWithOutput(a, b, c, d, e, f);} ); } +// popops::inv(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsInv", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::inv(a, b, c, d, e);} ); } +// popops::invInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsInvInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::invInPlace(a, b, c, d, e);} ); } +// popops::invWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsInvWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::invWithOutput(a, b, c, d, e, f);} ); } +// popops::log(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLog", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::log(a, b, c, d, e);} ); } +// popops::logInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLogInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::logInPlace(a, b, c, d, e);} ); } +// popops::logWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLogWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::logWithOutput(a, b, c, d, e, f);} ); } +// popops::log1p(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLog1P", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::log1p(a, b, c, d, e);} ); } +// popops::log1pInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLog1PInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::log1pInPlace(a, b, c, d, e);} ); } +// popops::log1pWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLog1PWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::log1pWithOutput(a, b, c, d, e, f);} ); } +// popops::logicalNot(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLogicalNot", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::logicalNot(a, b, c, d, e);} ); } +// popops::logicalNotInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLogicalNotInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::logicalNotInPlace(a, b, c, d, e);} ); } +// popops::logicalNotWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLogicalNotWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::logicalNotWithOutput(a, b, c, d, e, f);} ); } +// popops::neg(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsNeg", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::neg(a, b, c, d, e);} ); } +// popops::negInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsNegInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::negInPlace(a, b, c, d, e);} ); } +// popops::negWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsNegWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::negWithOutput(a, b, c, d, e, f);} ); } +// popops::popcount(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsPopcount", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::popcount(a, b, c, d, e);} ); } +// popops::popcountInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsPopcountInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::popcountInPlace(a, b, c, d, e);} ); } +// popops::popcountWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsPopcountWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::popcountWithOutput(a, b, c, d, e, f);} ); } +// popops::signum(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsSignum", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::signum(a, b, c, d, e);} ); } +// popops::signumInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsSignumInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::signumInPlace(a, b, c, d, e);} ); } +// popops::signumWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsSignumWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::signumWithOutput(a, b, c, d, e, f);} ); } +// popops::sin(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsSin", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::sin(a, b, c, d, e);} ); } +// popops::sinInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsSinInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::sinInPlace(a, b, c, d, e);} ); } +// popops::sinWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsSinWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::sinWithOutput(a, b, c, d, e, f);} ); } +// popops::tan(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsTan", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::tan(a, b, c, d, e);} ); } +// popops::tanInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsTanInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::tanInPlace(a, b, c, d, e);} ); } +// popops::tanWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsTanWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::tanWithOutput(a, b, c, d, e, f);} ); } +// popops::tanh(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsTanh", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::tanh(a, b, c, d, e);} ); } +// popops::tanhInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsTanhInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::tanhInPlace(a, b, c, d, e);} ); } +// popops::tanhWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsTanhWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::tanhWithOutput(a, b, c, d, e, f);} ); } +// popops::round(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsRound", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::round(a, b, c, d, e);} ); } +// popops::roundInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsRoundInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::roundInPlace(a, b, c, d, e);} ); } +// popops::roundWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsRoundWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::roundWithOutput(a, b, c, d, e, f);} ); } +// popops::sqrt(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsSqrt", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::sqrt(a, b, c, d, e);} ); } +// popops::sqrtInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsSqrtInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::sqrtInPlace(a, b, c, d, e);} ); } +// popops::sqrtWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsSqrtWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::sqrtWithOutput(a, b, c, d, e, f);} ); } +// popops::square(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsSquare", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::square(a, b, c, d, e);} ); } +// popops::squareInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsSquareInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::squareInPlace(a, b, c, d, e);} ); } +// popops::squareWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsSquareWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::squareWithOutput(a, b, c, d, e, f);} ); } +// popops::sigmoid(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsSigmoid", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::sigmoid(a, b, c, d, e);} ); } +// popops::sigmoidInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsSigmoidInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::sigmoidInPlace(a, b, c, d, e);} ); } +// popops::sigmoidWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsSigmoidWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::sigmoidWithOutput(a, b, c, d, e, f);} ); } +// popops::rsqrt(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsRsqrt", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::rsqrt(a, b, c, d, e);} ); } +// popops::rsqrtInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsRsqrtInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::rsqrtInPlace(a, b, c, d, e);} ); } +// popops::rsqrtWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsRsqrtWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::rsqrtWithOutput(a, b, c, d, e, f);} ); } +// popops::isFinite(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsIsFinite", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::isFinite(a, b, c, d, e);} ); } +// popops::isFiniteWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsIsFiniteWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::isFiniteWithOutput(a, b, c, d, e, f);} ); } +// popops::checkTypes<>(poplar::Type, float)__FunctionDecl +{ using namespace popops; +mod.method("PopopsCheckTypes<>", [](poplar::Type a, float b) {return popops::checkTypes<>(a, b);} ); } +// popops::checkTypes<>(poplar::Type, double)__FunctionDecl +{ using namespace popops; +mod.method("PopopsCheckTypes<>", [](poplar::Type a, double b) {return popops::checkTypes<>(a, b);} ); } +// popops::add(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsAdd", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::add(a, b, c, d, e, f);} ); } +// popops::addInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsAddInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::addInPlace(a, b, c, d, e, f);} ); } +// popops::addWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsAddWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::addWithOutput(a, b, c, d, e, f, g);} ); } +// popops::atan2(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsAtan2", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::atan2(a, b, c, d, e, f);} ); } +// popops::atan2InPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsAtan2InPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::atan2InPlace(a, b, c, d, e, f);} ); } +// popops::atan2WithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsAtan2WithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::atan2WithOutput(a, b, c, d, e, f, g);} ); } +// popops::bitwiseAnd(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsBitwiseAnd", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::bitwiseAnd(a, b, c, d, e, f);} ); } +// popops::bitwiseAndInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsBitwiseAndInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::bitwiseAndInPlace(a, b, c, d, e, f);} ); } +// popops::bitwiseAndWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsBitwiseAndWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::bitwiseAndWithOutput(a, b, c, d, e, f, g);} ); } +// popops::bitwiseOr(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsBitwiseOr", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::bitwiseOr(a, b, c, d, e, f);} ); } +// popops::bitwiseOrInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsBitwiseOrInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::bitwiseOrInPlace(a, b, c, d, e, f);} ); } +// popops::bitwiseOrWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsBitwiseOrWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::bitwiseOrWithOutput(a, b, c, d, e, f, g);} ); } +// popops::bitwiseXor(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsBitwiseXor", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::bitwiseXor(a, b, c, d, e, f);} ); } +// popops::bitwiseXorInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsBitwiseXorInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::bitwiseXorInPlace(a, b, c, d, e, f);} ); } +// popops::bitwiseXorWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsBitwiseXorWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::bitwiseXorWithOutput(a, b, c, d, e, f, g);} ); } +// popops::bitwiseXnor(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsBitwiseXnor", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::bitwiseXnor(a, b, c, d, e, f);} ); } +// popops::bitwiseXnorInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsBitwiseXnorInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::bitwiseXnorInPlace(a, b, c, d, e, f);} ); } +// popops::bitwiseXnorWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsBitwiseXnorWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::bitwiseXnorWithOutput(a, b, c, d, e, f, g);} ); } +// popops::div(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsDiv", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::div(a, b, c, d, e, f);} ); } +// popops::divInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsDivInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::divInPlace(a, b, c, d, e, f);} ); } +// popops::divWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsDivWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::divWithOutput(a, b, c, d, e, f, g);} ); } +// popops::eq(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsEq", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::eq(a, b, c, d, e, f);} ); } +// popops::eqInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsEqInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::eqInPlace(a, b, c, d, e, f);} ); } +// popops::eqWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsEqWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::eqWithOutput(a, b, c, d, e, f, g);} ); } +// popops::gteq(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsGteq", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::gteq(a, b, c, d, e, f);} ); } +// popops::gteqInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsGteqInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::gteqInPlace(a, b, c, d, e, f);} ); } +// popops::gteqWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsGteqWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::gteqWithOutput(a, b, c, d, e, f, g);} ); } +// popops::gt(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsGt", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::gt(a, b, c, d, e, f);} ); } +// popops::gtInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsGtInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::gtInPlace(a, b, c, d, e, f);} ); } +// popops::gtWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsGtWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::gtWithOutput(a, b, c, d, e, f, g);} ); } +// popops::invStdDevToVariance(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsInvStdDevToVariance", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::invStdDevToVariance(a, b, c, d, e, f);} ); } +// popops::invStdDevToVarianceInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsInvStdDevToVarianceInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::invStdDevToVarianceInPlace(a, b, c, d, e, f);} ); } +// popops::invStdDevToVarianceWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsInvStdDevToVarianceWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::invStdDevToVarianceWithOutput(a, b, c, d, e, f, g);} ); } +// popops::lteq(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLteq", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::lteq(a, b, c, d, e, f);} ); } +// popops::lteqInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLteqInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::lteqInPlace(a, b, c, d, e, f);} ); } +// popops::lteqWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLteqWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::lteqWithOutput(a, b, c, d, e, f, g);} ); } +// popops::logicalAnd(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLogicalAnd", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::logicalAnd(a, b, c, d, e, f);} ); } +// popops::logicalAndInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLogicalAndInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::logicalAndInPlace(a, b, c, d, e, f);} ); } +// popops::logicalAndWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLogicalAndWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::logicalAndWithOutput(a, b, c, d, e, f, g);} ); } +// popops::logicalOr(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLogicalOr", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::logicalOr(a, b, c, d, e, f);} ); } +// popops::logicalOrInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLogicalOrInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::logicalOrInPlace(a, b, c, d, e, f);} ); } +// popops::logicalOrWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLogicalOrWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::logicalOrWithOutput(a, b, c, d, e, f, g);} ); } +// popops::lt(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLt", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::lt(a, b, c, d, e, f);} ); } +// popops::ltInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLtInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::ltInPlace(a, b, c, d, e, f);} ); } +// popops::ltWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLtWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::ltWithOutput(a, b, c, d, e, f, g);} ); } +// popops::max(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsMax", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::max(a, b, c, d, e, f);} ); } +// popops::maxInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsMaxInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::maxInPlace(a, b, c, d, e, f);} ); } +// popops::maxWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsMaxWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::maxWithOutput(a, b, c, d, e, f, g);} ); } +// popops::min(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsMin", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::min(a, b, c, d, e, f);} ); } +// popops::minInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsMinInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::minInPlace(a, b, c, d, e, f);} ); } +// popops::minWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsMinWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::minWithOutput(a, b, c, d, e, f, g);} ); } +// popops::mul(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsMul", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::mul(a, b, c, d, e, f);} ); } +// popops::mulInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsMulInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::mulInPlace(a, b, c, d, e, f);} ); } +// popops::mulWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsMulWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::mulWithOutput(a, b, c, d, e, f, g);} ); } +// popops::neq(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsNeq", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::neq(a, b, c, d, e, f);} ); } +// popops::neqInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsNeqInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::neqInPlace(a, b, c, d, e, f);} ); } +// popops::neqWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsNeqWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::neqWithOutput(a, b, c, d, e, f, g);} ); } +// popops::pow(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsPow", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::pow(a, b, c, d, e, f);} ); } +// popops::powInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsPowInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::powInPlace(a, b, c, d, e, f);} ); } +// popops::powWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsPowWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::powWithOutput(a, b, c, d, e, f, g);} ); } +// popops::rem(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsRem", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::rem(a, b, c, d, e, f);} ); } +// popops::remInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsRemInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::remInPlace(a, b, c, d, e, f);} ); } +// popops::remWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsRemWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::remWithOutput(a, b, c, d, e, f, g);} ); } +// popops::shiftLeft(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsShiftLeft", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::shiftLeft(a, b, c, d, e, f);} ); } +// popops::shiftLeftInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsShiftLeftInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::shiftLeftInPlace(a, b, c, d, e, f);} ); } +// popops::shiftLeftWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsShiftLeftWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::shiftLeftWithOutput(a, b, c, d, e, f, g);} ); } +// popops::shiftRight(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsShiftRight", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::shiftRight(a, b, c, d, e, f);} ); } +// popops::shiftRightInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsShiftRightInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::shiftRightInPlace(a, b, c, d, e, f);} ); } +// popops::shiftRightWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsShiftRightWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::shiftRightWithOutput(a, b, c, d, e, f, g);} ); } +// popops::shiftRightSignExtend(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsShiftRightSignExtend", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::shiftRightSignExtend(a, b, c, d, e, f);} ); } +// popops::shiftRightSignExtendInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsShiftRightSignExtendInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::shiftRightSignExtendInPlace(a, b, c, d, e, f);} ); } +// popops::shiftRightSignExtendWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsShiftRightSignExtendWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::shiftRightSignExtendWithOutput(a, b, c, d, e, f, g);} ); } +// popops::sub(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsSub", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::sub(a, b, c, d, e, f);} ); } +// popops::subInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsSubInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::subInPlace(a, b, c, d, e, f);} ); } +// popops::subWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsSubWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::subWithOutput(a, b, c, d, e, f, g);} ); } +// popops::varianceToInvStdDev(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsVarianceToInvStdDev", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::varianceToInvStdDev(a, b, c, d, e, f);} ); } +// popops::varianceToInvStdDevInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsVarianceToInvStdDevInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::varianceToInvStdDevInPlace(a, b, c, d, e, f);} ); } +// popops::varianceToInvStdDevWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsVarianceToInvStdDevWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::varianceToInvStdDevWithOutput(a, b, c, d, e, f, g);} ); } +// popops::select(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsSelect", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::select(a, b, c, d, e, f, g);} ); } +// popops::selectInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsSelectInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::selectInPlace(a, b, c, d, e, f, g);} ); } +// popops::selectWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsSelectWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, const poplar::Tensor & e, poplar::program::Sequence & f, std::string g, const poplar::OptionFlags & h) {return popops::selectWithOutput(a, b, c, d, e, f, g, h);} ); } +// popops::clamp(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsClamp", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::clamp(a, b, c, d, e, f, g);} ); } +// popops::clampInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsClampInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::clampInPlace(a, b, c, d, e, f, g);} ); } +// popops::clampWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsClampWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, const poplar::Tensor & e, poplar::program::Sequence & f, std::string g, const poplar::OptionFlags & h) {return popops::clampWithOutput(a, b, c, d, e, f, g, h);} ); } +// popops::addCodelets(poplar::Graph &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsAddCodelets", [](poplar::Graph & a) {return popops::addCodelets(a);} ); } From 88771b69f67ea64661e026b35b2aece604385661 Mon Sep 17 00:00:00 2001 From: Gnimuc Date: Tue, 20 Aug 2024 23:20:18 +0900 Subject: [PATCH 3/6] 3.2 diff --- deps/wrapper/gen_inline.cpp | 1172 ++++++++++++++++++----------------- 1 file changed, 601 insertions(+), 571 deletions(-) diff --git a/deps/wrapper/gen_inline.cpp b/deps/wrapper/gen_inline.cpp index 643d10c..961b020 100644 --- a/deps/wrapper/gen_inline.cpp +++ b/deps/wrapper/gen_inline.cpp @@ -278,9 +278,9 @@ mod.set_const("LayoutVectorLayoutScaledPtr32", poplar::layout::Vector::ScaledPtr mod.set_const("LayoutVectorLayoutScaledPtr64", poplar::layout::Vector::ScaledPtr64); // poplar::layout::Vector::ScaledPtr128__EnumConstantDecl mod.set_const("LayoutVectorLayoutScaledPtr128", poplar::layout::Vector::ScaledPtr128); -// poplar::layout::to_string(const poplar::layout::Vector)__FunctionDecl +// poplar::layout::to_string(const Vector)__FunctionDecl { using namespace poplar::layout; -mod.method("LayoutTo_String", [](const poplar::layout::Vector a) {return poplar::layout::to_string(a);} ); } +mod.method("LayoutTo_String", [](const Vector a) {return poplar::layout::to_string(a);} ); } // poplar::layout::VectorList::NotAVector__EnumConstantDecl mod.set_const("LayoutVectorListLayoutNotAVector", poplar::layout::VectorList::NotAVector); // poplar::layout::VectorList::OnePtr__EnumConstantDecl @@ -295,6 +295,13 @@ mod.set_const("LayoutVectorListLayoutScaledPtr128", poplar::layout::VectorList:: mod.set_const("LayoutVectorListLayoutDeltaN", poplar::layout::VectorList::DeltaN); // poplar::layout::VectorList::DeltaNElements__EnumConstantDecl mod.set_const("LayoutVectorListLayoutDeltaNElements", poplar::layout::VectorList::DeltaNElements); +// poplar::layout::to_string(const VectorList)__FunctionDecl +{ using namespace poplar::layout; +mod.method("LayoutTo_String", [](const VectorList a) {return poplar::layout::to_string(a);} ); } +// std::string::StringRef(const StringRef &)__CXXConstructor +{ using namespace poplar; +JLStringRef.constructor(); +} // std::string::StringRef(const std::string &)__CXXConstructor { using namespace poplar; JLStringRef.constructor(); @@ -311,21 +318,21 @@ JLStringRef.constructor(); { using namespace poplar; JLStringRef.method("StringRefCloneAsString", [](poplar::StringRef& cl) {return cl.cloneAsString();}); } -// poplar::OptionFlags::iterator::iterator(const poplar::OptionFlags::iterator &)__CXXConstructor +// poplar::OptionFlags::iterator::iterator(const iterator &)__CXXConstructor { using namespace poplar; -JLOptionFlagsiterator.constructor(); +JLOptionFlagsiterator.constructor(); } -// poplar::OptionFlags::OptionFlags(const poplar::OptionFlags &)__CXXConstructor +// poplar::OptionFlags::OptionFlags(const OptionFlags &)__CXXConstructor { using namespace poplar; -JLOptionFlags.constructor(); +JLOptionFlags.constructor(); } -// poplar::OptionFlags::set(std::string, std::string)__CXXMethod +// poplar::OptionFlags::set(StringRef, StringRef)__CXXMethod { using namespace poplar; -JLOptionFlags.method("OptionFlagsSet", [](poplar::OptionFlags& cl, std::string a, std::string b) {return cl.set(a, b);}); +JLOptionFlags.method("OptionFlagsSet", [](poplar::OptionFlags& cl, StringRef a, StringRef b) {return cl.set(a, b);}); } -// poplar::OptionFlags::at(std::string)__CXXMethod +// poplar::OptionFlags::at(StringRef)__CXXMethod { using namespace poplar; -JLOptionFlags.method("OptionFlagsAt", [](poplar::OptionFlags& cl, std::string a) {return cl.at(a);}); +JLOptionFlags.method("OptionFlagsAt", [](poplar::OptionFlags& cl, StringRef a) {return cl.at(a);}); } // poplar::OptionFlags::clear()__CXXMethod { using namespace poplar; @@ -339,22 +346,22 @@ JLOptionFlags.method("OptionFlagsBegin", [](poplar::OptionFlags& cl) {return cl. { using namespace poplar; JLOptionFlags.method("OptionFlagsEnd", [](poplar::OptionFlags& cl) {return cl.end();}); } -// poplar::getAsProfileValue(const poplar::OptionFlags &)__FunctionDecl +// poplar::getAsProfileValue(const OptionFlags &)__FunctionDecl { using namespace poplar; -mod.method("PoplarGetAsProfileValue", [](const poplar::OptionFlags & a) {return poplar::getAsProfileValue(a);} ); } -// poplar::readJSON(std::string, poplar::OptionFlags &)__FunctionDecl +mod.method("PoplarGetAsProfileValue", [](const OptionFlags & a) {return poplar::getAsProfileValue(a);} ); } +// poplar::readJSON(StringRef, OptionFlags &)__FunctionDecl { using namespace poplar; -mod.method("PoplarReadJSON", [](std::string a, poplar::OptionFlags & b) {return poplar::readJSON(a, b);} ); } -// poplar::readJSONFromEnv(std::string, poplar::OptionFlags &)__FunctionDecl +mod.method("PoplarReadJSON", [](StringRef a, OptionFlags & b) {return poplar::readJSON(a, b);} ); } +// poplar::readJSONFromEnv(StringRef, OptionFlags &)__FunctionDecl { using namespace poplar; -mod.method("PoplarReadJSONFromEnv", [](std::string a, poplar::OptionFlags & b) {return poplar::readJSONFromEnv(a, b);} ); } +mod.method("PoplarReadJSONFromEnv", [](StringRef a, OptionFlags & b) {return poplar::readJSONFromEnv(a, b);} ); } // poplar::GlobalExchangeFlow::GlobalExchangeFlow(unsigned int, unsigned int)__CXXConstructor { using namespace poplar; JLGlobalExchangeFlow.constructor(); } -// poplar::GlobalExchangeConstraint::GlobalExchangeConstraint(double, ArrayRef)__CXXConstructor +// poplar::GlobalExchangeConstraint::GlobalExchangeConstraint(double, ArrayRef)__CXXConstructor { using namespace poplar; -JLGlobalExchangeConstraint.constructor>(); +JLGlobalExchangeConstraint.constructor>(); } // poplar::IpuLinkConfiguration::Default__EnumConstantDecl mod.set_const("PoplarIpuLinkConfigurationPoplarDefault", poplar::IpuLinkConfiguration::Default); @@ -372,9 +379,9 @@ mod.set_const("PoplarTargetTypePoplarIPU", poplar::TargetType::IPU); mod.set_const("PoplarTargetTypePoplarIPU_MODEL", poplar::TargetType::IPU_MODEL); // poplar::TargetType::CPU__EnumConstantDecl mod.set_const("PoplarTargetTypePoplarCPU", poplar::TargetType::CPU); -// poplar::Type::Type(const poplar::Type &)__CXXConstructor +// poplar::Type::Type(const Type &)__CXXConstructor { using namespace poplar; -JLType.constructor(); +JLType.constructor(); } // poplar::Type::toString()__CXXMethod { using namespace poplar; @@ -392,9 +399,9 @@ JLType.method("TypeIsFloatingPoint", [](poplar::Type& cl) {return cl.isFloatingP { using namespace poplar; JLType.method("TypeRequiresMetadata", [](poplar::Type& cl) {return cl.requiresMetadata();}); } -// poplar::Target::Target(const poplar::Target &)__CXXConstructor +// poplar::Target::Target(const Target &)__CXXConstructor { using namespace poplar; -JLTarget.constructor(); +JLTarget.constructor(); } // poplar::Target::hash()__CXXMethod { using namespace poplar; @@ -540,21 +547,21 @@ JLTarget.method("TargetGetQuarterVectorWidth", [](poplar::Target& cl) {return cl { using namespace poplar; JLTarget.method("TargetGetVectorWidth", [](poplar::Target& cl, const poplar::Type & a) {return cl.getVectorWidth(a);}); } -// poplar::Target::getWeightsPerConvUnit(const poplar::Type &)__CXXMethod +// poplar::Target::getWeightsPerConvUnit(const Type &)__CXXMethod { using namespace poplar; -JLTarget.method("TargetGetWeightsPerConvUnit", [](poplar::Target& cl, const poplar::Type & a) {return cl.getWeightsPerConvUnit(a);}); +JLTarget.method("TargetGetWeightsPerConvUnit", [](poplar::Target& cl, const Type & a) {return cl.getWeightsPerConvUnit(a);}); } -// poplar::Target::getConvUnitInputLoadElemsPerCycle(const poplar::Type &)__CXXMethod +// poplar::Target::getConvUnitInputLoadElemsPerCycle(const Type &)__CXXMethod { using namespace poplar; -JLTarget.method("TargetGetConvUnitInputLoadElemsPerCycle", [](poplar::Target& cl, const poplar::Type & a) {return cl.getConvUnitInputLoadElemsPerCycle(a);}); +JLTarget.method("TargetGetConvUnitInputLoadElemsPerCycle", [](poplar::Target& cl, const Type & a) {return cl.getConvUnitInputLoadElemsPerCycle(a);}); } -// poplar::Target::getConvUnitMaxPipelineDepth(const poplar::Type &)__CXXMethod +// poplar::Target::getConvUnitMaxPipelineDepth(const Type &)__CXXMethod { using namespace poplar; -JLTarget.method("TargetGetConvUnitMaxPipelineDepth", [](poplar::Target& cl, const poplar::Type & a) {return cl.getConvUnitMaxPipelineDepth(a);}); +JLTarget.method("TargetGetConvUnitMaxPipelineDepth", [](poplar::Target& cl, const Type & a) {return cl.getConvUnitMaxPipelineDepth(a);}); } -// poplar::Target::getNumConvUnits(const poplar::Type &, const poplar::Type &)__CXXMethod +// poplar::Target::getNumConvUnits(const Type &, const Type &)__CXXMethod { using namespace poplar; -JLTarget.method("TargetGetNumConvUnits", [](poplar::Target& cl, const poplar::Type & a, const poplar::Type & b) {return cl.getNumConvUnits(a, b);}); +JLTarget.method("TargetGetNumConvUnits", [](poplar::Target& cl, const Type & a, const Type & b) {return cl.getNumConvUnits(a, b);}); } // poplar::Target::getMaxIPUSyncDelay()__CXXMethod { using namespace poplar; @@ -584,9 +591,9 @@ JLTarget.method("TargetGetTileHostExchangeContext", [](poplar::Target& cl, unsig { using namespace poplar; JLTarget.method("TargetGetTileHostExchangeContextPosition", [](poplar::Target& cl, unsigned int a) {return cl.getTileHostExchangeContextPosition(a);}); } -// poplar::Target::getTypeSize(const poplar::Type &)__CXXMethod +// poplar::Target::getTypeSize(const Type &)__CXXMethod { using namespace poplar; -JLTarget.method("TargetGetTypeSize", [](poplar::Target& cl, const poplar::Type & a) {return cl.getTypeSize(a);}); +JLTarget.method("TargetGetTypeSize", [](poplar::Target& cl, const Type & a) {return cl.getTypeSize(a);}); } // poplar::Target::getAtomicStoreGranularity()__CXXMethod { using namespace poplar; @@ -634,33 +641,33 @@ JLTarget.method("TargetCreateCPUTarget", [](poplar::Target& cl) {return cl.creat JLTarget.method("TargetCreateCPUTarget", [](poplar::Target& cl, bool a) {return cl.createCPUTarget(a);}); JLTarget.method("TargetCreateCPUTarget", [](poplar::Target& cl, bool a, unsigned int b) {return cl.createCPUTarget(a, b);}); } -// poplar::Target::createIPUTarget(std::string, const poplar::OptionFlags &)__CXXMethod +// poplar::Target::createIPUTarget(StringRef, const OptionFlags &)__CXXMethod { using namespace poplar; -JLTarget.method("TargetCreateIPUTarget", [](poplar::Target& cl, std::string a) {return cl.createIPUTarget(a);}); -JLTarget.method("TargetCreateIPUTarget", [](poplar::Target& cl, std::string a, const poplar::OptionFlags & b) {return cl.createIPUTarget(a, b);}); +JLTarget.method("TargetCreateIPUTarget", [](poplar::Target& cl, StringRef a) {return cl.createIPUTarget(a);}); +JLTarget.method("TargetCreateIPUTarget", [](poplar::Target& cl, StringRef a, const OptionFlags & b) {return cl.createIPUTarget(a, b);}); } -// poplar::Target::createIPUTarget(unsigned int, std::string, const poplar::OptionFlags &)__CXXMethod +// poplar::Target::createIPUTarget(unsigned int, StringRef, const OptionFlags &)__CXXMethod { using namespace poplar; -JLTarget.method("TargetCreateIPUTarget", [](poplar::Target& cl, unsigned int a, std::string b) {return cl.createIPUTarget(a, b);}); -JLTarget.method("TargetCreateIPUTarget", [](poplar::Target& cl, unsigned int a, std::string b, const poplar::OptionFlags & c) {return cl.createIPUTarget(a, b, c);}); +JLTarget.method("TargetCreateIPUTarget", [](poplar::Target& cl, unsigned int a, StringRef b) {return cl.createIPUTarget(a, b);}); +JLTarget.method("TargetCreateIPUTarget", [](poplar::Target& cl, unsigned int a, StringRef b, const OptionFlags & c) {return cl.createIPUTarget(a, b, c);}); } -// poplar::Target::createIPUTarget(unsigned int, unsigned int, std::string, const poplar::OptionFlags &)__CXXMethod +// poplar::Target::createIPUTarget(unsigned int, unsigned int, StringRef, const OptionFlags &)__CXXMethod { using namespace poplar; -JLTarget.method("TargetCreateIPUTarget", [](poplar::Target& cl, unsigned int a, unsigned int b, std::string c) {return cl.createIPUTarget(a, b, c);}); -JLTarget.method("TargetCreateIPUTarget", [](poplar::Target& cl, unsigned int a, unsigned int b, std::string c, const poplar::OptionFlags & d) {return cl.createIPUTarget(a, b, c, d);}); +JLTarget.method("TargetCreateIPUTarget", [](poplar::Target& cl, unsigned int a, unsigned int b, StringRef c) {return cl.createIPUTarget(a, b, c);}); +JLTarget.method("TargetCreateIPUTarget", [](poplar::Target& cl, unsigned int a, unsigned int b, StringRef c, const OptionFlags & d) {return cl.createIPUTarget(a, b, c, d);}); } -// poplar::copyDeviceHalfToFloat(const poplar::Target &, const void *, float *, std::size_t)__FunctionDecl +// poplar::copyDeviceHalfToFloat(const Target &, const void *, float *, std::size_t)__FunctionDecl { using namespace poplar; -mod.method("PoplarCopyDeviceHalfToFloat", [](const poplar::Target & a, const void * b, float * c, std::size_t d) {return poplar::copyDeviceHalfToFloat(a, b, c, d);} ); } -// poplar::copyFloatToDeviceHalf(const poplar::Target &, const float *, void *, std::size_t)__FunctionDecl +mod.method("PoplarCopyDeviceHalfToFloat", [](const Target & a, const void * b, float * c, std::size_t d) {return poplar::copyDeviceHalfToFloat(a, b, c, d);} ); } +// poplar::copyFloatToDeviceHalf(const Target &, const float *, void *, std::size_t)__FunctionDecl { using namespace poplar; -mod.method("PoplarCopyFloatToDeviceHalf", [](const poplar::Target & a, const float * b, void * c, std::size_t d) {return poplar::copyFloatToDeviceHalf(a, b, c, d);} ); } -// poplar::copyDeviceHalfToDouble(const poplar::Target &, const void *, double *, std::size_t)__FunctionDecl +mod.method("PoplarCopyFloatToDeviceHalf", [](const Target & a, const float * b, void * c, std::size_t d) {return poplar::copyFloatToDeviceHalf(a, b, c, d);} ); } +// poplar::copyDeviceHalfToDouble(const Target &, const void *, double *, std::size_t)__FunctionDecl { using namespace poplar; -mod.method("PoplarCopyDeviceHalfToDouble", [](const poplar::Target & a, const void * b, double * c, std::size_t d) {return poplar::copyDeviceHalfToDouble(a, b, c, d);} ); } -// poplar::copyDoubleToDeviceHalf(const poplar::Target &, const double *, void *, std::size_t)__FunctionDecl +mod.method("PoplarCopyDeviceHalfToDouble", [](const Target & a, const void * b, double * c, std::size_t d) {return poplar::copyDeviceHalfToDouble(a, b, c, d);} ); } +// poplar::copyDoubleToDeviceHalf(const Target &, const double *, void *, std::size_t)__FunctionDecl { using namespace poplar; -mod.method("PoplarCopyDoubleToDeviceHalf", [](const poplar::Target & a, const double * b, void * c, std::size_t d) {return poplar::copyDoubleToDeviceHalf(a, b, c, d);} ); } +mod.method("PoplarCopyDoubleToDeviceHalf", [](const Target & a, const double * b, void * c, std::size_t d) {return poplar::copyDoubleToDeviceHalf(a, b, c, d);} ); } // poplar::Device::getId()__CXXMethod { using namespace poplar; JLDevice.method("DeviceGetId", [](poplar::Device& cl) {return cl.getId();}); @@ -718,23 +725,23 @@ JLDevice.method("DeviceCreateVirtualDevice", [](poplar::Device& cl, unsigned int JLDevice.method("DeviceCreateCPUDevice", [](poplar::Device& cl) {return cl.createCPUDevice();}); JLDevice.method("DeviceCreateCPUDevice", [](poplar::Device& cl, unsigned int a) {return cl.createCPUDevice(a);}); } -// poplar::Device::createSimulatorDevice(const poplar::Target &, const poplar::OptionFlags &)__CXXMethod +// poplar::Device::createSimulatorDevice(const Target &, const OptionFlags &)__CXXMethod { using namespace poplar; -JLDevice.method("DeviceCreateSimulatorDevice", [](poplar::Device& cl, const poplar::Target & a) {return cl.createSimulatorDevice(a);}); -JLDevice.method("DeviceCreateSimulatorDevice", [](poplar::Device& cl, const poplar::Target & a, const poplar::OptionFlags & b) {return cl.createSimulatorDevice(a, b);}); +JLDevice.method("DeviceCreateSimulatorDevice", [](poplar::Device& cl, const Target & a) {return cl.createSimulatorDevice(a);}); +JLDevice.method("DeviceCreateSimulatorDevice", [](poplar::Device& cl, const Target & a, const OptionFlags & b) {return cl.createSimulatorDevice(a, b);}); } -// poplar::DeviceManager::DeviceManager(const poplar::DeviceManager &)__CXXConstructor +// poplar::DeviceManager::DeviceManager(const DeviceManager &)__CXXConstructor { using namespace poplar; -JLDeviceManager.constructor(); +JLDeviceManager.constructor(); } // poplar::DeviceManager::getNumDevices()__CXXMethod { using namespace poplar; JLDeviceManager.method("DeviceManagerGetNumDevices", [](poplar::DeviceManager& cl) {return cl.getNumDevices();}); } -// poplar::DeviceManager::getDevice(unsigned int, const poplar::OptionFlags &)__CXXMethod +// poplar::DeviceManager::getDevice(unsigned int, const OptionFlags &)__CXXMethod { using namespace poplar; JLDeviceManager.method("DeviceManagerGetDevice", [](poplar::DeviceManager& cl, unsigned int a) {return cl.getDevice(a);}); -JLDeviceManager.method("DeviceManagerGetDevice", [](poplar::DeviceManager& cl, unsigned int a, const poplar::OptionFlags & b) {return cl.getDevice(a, b);}); +JLDeviceManager.method("DeviceManagerGetDevice", [](poplar::DeviceManager& cl, unsigned int a, const OptionFlags & b) {return cl.getDevice(a, b);}); } // poplar::DeviceManager::getChildDeviceIds(unsigned int, unsigned int)__CXXMethod { using namespace poplar; @@ -762,12 +769,12 @@ mod.set_const("PoplarCodeletFileTypePoplarAuto", poplar::CodeletFileType::Auto); // poplar::getCodeletFileType(const char *)__FunctionDecl { using namespace poplar; mod.method("PoplarGetCodeletFileType", [](const char * a) {return poplar::getCodeletFileType(a);} ); } -// poplar::getExtensionFromFileType(poplar::CodeletFileType)__FunctionDecl +// poplar::getExtensionFromFileType(CodeletFileType)__FunctionDecl { using namespace poplar; -mod.method("PoplarGetExtensionFromFileType", [](poplar::CodeletFileType a) {return poplar::getExtensionFromFileType(a);} ); } -// poplar::getLanguageOption(poplar::CodeletFileType)__FunctionDecl +mod.method("PoplarGetExtensionFromFileType", [](CodeletFileType a) {return poplar::getExtensionFromFileType(a);} ); } +// poplar::getLanguageOption(CodeletFileType)__FunctionDecl { using namespace poplar; -mod.method("PoplarGetLanguageOption", [](poplar::CodeletFileType a) {return poplar::getLanguageOption(a);} ); } +mod.method("PoplarGetLanguageOption", [](CodeletFileType a) {return poplar::getLanguageOption(a);} ); } // poplar::DataStreamType::HostToDeviceFIFO__EnumConstantDecl mod.set_const("PoplarDataStreamTypePoplarHostToDeviceFIFO", poplar::DataStreamType::HostToDeviceFIFO); // poplar::DataStreamType::DeviceToHostFIFO__EnumConstantDecl @@ -776,22 +783,22 @@ mod.set_const("PoplarDataStreamTypePoplarDeviceToHostFIFO", poplar::DataStreamTy mod.set_const("PoplarDataStreamTypePoplarHostToDeviceBuffer", poplar::DataStreamType::HostToDeviceBuffer); // poplar::DataStreamType::DeviceToHostBuffer__EnumConstantDecl mod.set_const("PoplarDataStreamTypePoplarDeviceToHostBuffer", poplar::DataStreamType::DeviceToHostBuffer); -// poplar::isDeviceToHost(poplar::DataStreamType)__FunctionDecl +// poplar::isDeviceToHost(DataStreamType)__FunctionDecl { using namespace poplar; -mod.method("PoplarIsDeviceToHost", [](poplar::DataStreamType a) {return poplar::isDeviceToHost(a);} ); } -// poplar::isHostToDevice(poplar::DataStreamType)__FunctionDecl +mod.method("PoplarIsDeviceToHost", [](DataStreamType a) {return poplar::isDeviceToHost(a);} ); } +// poplar::isHostToDevice(DataStreamType)__FunctionDecl { using namespace poplar; -mod.method("PoplarIsHostToDevice", [](poplar::DataStreamType a) {return poplar::isHostToDevice(a);} ); } -// poplar::isRemoteBuffer(poplar::DataStreamType)__FunctionDecl +mod.method("PoplarIsHostToDevice", [](DataStreamType a) {return poplar::isHostToDevice(a);} ); } +// poplar::isRemoteBuffer(DataStreamType)__FunctionDecl { using namespace poplar; -mod.method("PoplarIsRemoteBuffer", [](poplar::DataStreamType a) {return poplar::isRemoteBuffer(a);} ); } +mod.method("PoplarIsRemoteBuffer", [](DataStreamType a) {return poplar::isRemoteBuffer(a);} ); } // poplar::ReplicatedStreamMode::REPLICATE__EnumConstantDecl mod.set_const("PoplarReplicatedStreamModePoplarREPLICATE", poplar::ReplicatedStreamMode::REPLICATE); // poplar::ReplicatedStreamMode::BROADCAST__EnumConstantDecl mod.set_const("PoplarReplicatedStreamModePoplarBROADCAST", poplar::ReplicatedStreamMode::BROADCAST); -// poplar::DataStream::DataStream(const poplar::DataStream &)__CXXConstructor +// poplar::DataStream::DataStream(const DataStream &)__CXXConstructor { using namespace poplar; -JLDataStream.constructor(); +JLDataStream.constructor(); } // poplar::DataStream::handle()__CXXMethod { using namespace poplar; @@ -817,9 +824,9 @@ JLDataStream.method("DataStreamType", [](poplar::DataStream& cl) {return cl.type { using namespace poplar; JLDataStream.method("DataStreamElementType", [](poplar::DataStream& cl) {return cl.elementType();}); } -// poplar::RemoteBuffer::RemoteBuffer(const poplar::RemoteBuffer &)__CXXConstructor +// poplar::RemoteBuffer::RemoteBuffer(const RemoteBuffer &)__CXXConstructor { using namespace poplar; -JLRemoteBuffer.constructor(); +JLRemoteBuffer.constructor(); } // poplar::RemoteBuffer::handle()__CXXMethod { using namespace poplar; @@ -887,9 +894,9 @@ JLProfileValue.method("ProfileValueAsUint", [](poplar::ProfileValue& cl) {return { using namespace poplar; JLProfileValue.method("ProfileValueAsDouble", [](poplar::ProfileValue& cl) {return cl.asDouble();}); } -// poplar::ProfileValue::getOrNull(std::string)__CXXMethod +// poplar::ProfileValue::getOrNull(StringRef)__CXXMethod { using namespace poplar; -JLProfileValue.method("ProfileValueGetOrNull", [](poplar::ProfileValue& cl, std::string a) {return cl.getOrNull(a);}); +JLProfileValue.method("ProfileValueGetOrNull", [](poplar::ProfileValue& cl, StringRef a) {return cl.getOrNull(a);}); } // poplar::ProfileValue::asMap()__CXXMethod { using namespace poplar; @@ -927,33 +934,33 @@ JLProfileValue.method("ProfileValueSum2DInt", [](poplar::ProfileValue& cl) {retu { using namespace poplar; JLProfileValue.method("ProfileValueSum2DUint", [](poplar::ProfileValue& cl) {return cl.sum2DUint();}); } -// poplar::ProfileValue::ProfileValue(poplar::ProfileValue::String)__CXXConstructor +// poplar::ProfileValue::ProfileValue(String)__CXXConstructor { using namespace poplar; -JLProfileValue.constructor(); +JLProfileValue.constructor(); } -// poplar::ProfileValue::ProfileValue(poplar::ProfileValue::Vector)__CXXConstructor +// poplar::ProfileValue::ProfileValue(Vector)__CXXConstructor { using namespace poplar; -JLProfileValue.constructor(); +JLProfileValue.constructor(); } -// poplar::ProfileValue::ProfileValue(poplar::ProfileValue::Map)__CXXConstructor +// poplar::ProfileValue::ProfileValue(Map)__CXXConstructor { using namespace poplar; -JLProfileValue.constructor(); +JLProfileValue.constructor(); } -// poplar::ProfileValue::ProfileValue(poplar::ProfileValue::Number)__CXXConstructor +// poplar::ProfileValue::ProfileValue(Number)__CXXConstructor { using namespace poplar; -JLProfileValue.constructor(); +JLProfileValue.constructor(); } -// poplar::ProfileValue::ProfileValue(poplar::ProfileValue::Boolean)__CXXConstructor +// poplar::ProfileValue::ProfileValue(Boolean)__CXXConstructor { using namespace poplar; -JLProfileValue.constructor(); +JLProfileValue.constructor(); } // poplar::ProfileValue::ProfileValue(const char *)__CXXConstructor { using namespace poplar; JLProfileValue.constructor(); } -// poplar::ProfileValue::ProfileValue(const poplar::ProfileValue &)__CXXConstructor +// poplar::ProfileValue::ProfileValue(const ProfileValue &)__CXXConstructor { using namespace poplar; -JLProfileValue.constructor(); +JLProfileValue.constructor(); } // poplar::SerializationFormat::Binary__EnumConstantDecl mod.set_const("PoplarSerializationFormatPoplarBinary", poplar::SerializationFormat::Binary); @@ -990,9 +997,9 @@ JLSourceLocation.method("SourceLocationCurrent", [](poplar::SourceLocation& cl, mod.set_const("PoplarDebugSerializationFormatPoplarJSON", poplar::DebugSerializationFormat::JSON); // poplar::DebugSerializationFormat::CBOR__EnumConstantDecl mod.set_const("PoplarDebugSerializationFormatPoplarCBOR", poplar::DebugSerializationFormat::CBOR); -// poplar::DebugInfo::DebugInfo(const poplar::DebugContext &, std::string)__CXXConstructor +// poplar::DebugInfo::DebugInfo(const DebugContext &, std::string)__CXXConstructor { using namespace poplar; -JLDebugInfo.constructor(); +JLDebugInfo.constructor(); } // poplar::DebugInfo::getId()__CXXMethod { using namespace poplar; @@ -1002,42 +1009,42 @@ JLDebugInfo.method("DebugInfoGetId", [](poplar::DebugInfo& cl) {return cl.getId( { using namespace poplar; JLDebugInfo.method("DebugInfoGetPathName", [](poplar::DebugInfo& cl) {return cl.getPathName();}); } -// poplar::DebugInfo::initializeStreamer(const std::string &, const poplar::DebugSerializationFormat &)__CXXMethod +// poplar::DebugInfo::initializeStreamer(const std::string &, const DebugSerializationFormat &)__CXXMethod { using namespace poplar; JLDebugInfo.method("DebugInfoInitializeStreamer", [](poplar::DebugInfo& cl, const std::string & a) {return cl.initializeStreamer(a);}); -JLDebugInfo.method("DebugInfoInitializeStreamer", [](poplar::DebugInfo& cl, const std::string & a, const poplar::DebugSerializationFormat & b) {return cl.initializeStreamer(a, b);}); +JLDebugInfo.method("DebugInfoInitializeStreamer", [](poplar::DebugInfo& cl, const std::string & a, const DebugSerializationFormat & b) {return cl.initializeStreamer(a, b);}); } // poplar::DebugInfo::closeStreamer()__CXXMethod { using namespace poplar; JLDebugInfo.method("DebugInfoCloseStreamer", [](poplar::DebugInfo& cl) {return cl.closeStreamer();}); } -// poplar::DebugInfo::setValue(std::string, poplar::ProfileValue)__CXXMethod +// poplar::DebugInfo::setValue(std::string, ProfileValue)__CXXMethod { using namespace poplar; -JLDebugInfo.method("DebugInfoSetValue", [](poplar::DebugInfo& cl, std::string a, poplar::ProfileValue b) {return cl.setValue(a, b);}); +JLDebugInfo.method("DebugInfoSetValue", [](poplar::DebugInfo& cl, std::string a, ProfileValue b) {return cl.setValue(a, b);}); } -// poplar::DebugNameAndId::DebugNameAndId(std::string, poplar::DebugId, std::string)__CXXConstructor +// poplar::DebugNameAndId::DebugNameAndId(std::string, DebugId, std::string)__CXXConstructor { using namespace poplar; JLDebugNameAndId.constructor(); -JLDebugNameAndId.constructor(); -JLDebugNameAndId.constructor(); +JLDebugNameAndId.constructor(); +JLDebugNameAndId.constructor(); } // poplar::DebugNameAndId::DebugNameAndId(const char *)__CXXConstructor { using namespace poplar; JLDebugNameAndId.constructor(); } -// poplar::DebugNameAndId::DebugNameAndId(poplar::DebugId)__CXXConstructor +// poplar::DebugNameAndId::DebugNameAndId(DebugId)__CXXConstructor { using namespace poplar; -JLDebugNameAndId.constructor(); +JLDebugNameAndId.constructor(); } -// poplar::DebugNameAndId::DebugNameAndId(const poplar::DebugInfo &, std::string)__CXXConstructor +// poplar::DebugNameAndId::DebugNameAndId(const DebugInfo &, std::string)__CXXConstructor { using namespace poplar; -JLDebugNameAndId.constructor(); -JLDebugNameAndId.constructor(); +JLDebugNameAndId.constructor(); +JLDebugNameAndId.constructor(); } -// poplar::DebugNameAndId::DebugNameAndId(const poplar::DebugNameAndId &, std::string)__CXXConstructor +// poplar::DebugNameAndId::DebugNameAndId(const DebugNameAndId &, StringRef)__CXXConstructor { using namespace poplar; -JLDebugNameAndId.constructor(); -JLDebugNameAndId.constructor(); +JLDebugNameAndId.constructor(); +JLDebugNameAndId.constructor(); } // poplar::DebugNameAndId::getPathName()__CXXMethod { using namespace poplar; @@ -1131,19 +1138,19 @@ mod.set_const("PoplarErrorCodePoplarHOST_LINK_DOWN", poplar::ErrorCode::HOST_LIN mod.set_const("PoplarErrorCodePoplarHOST_SYNC_TIMEOUT", poplar::ErrorCode::HOST_SYNC_TIMEOUT); // poplar::ErrorCode::IPU_MEMORY_FAILURE__EnumConstantDecl mod.set_const("PoplarErrorCodePoplarIPU_MEMORY_FAILURE", poplar::ErrorCode::IPU_MEMORY_FAILURE); -// poplar::errorCodeToString(poplar::ErrorCode)__FunctionDecl +// poplar::errorCodeToString(ErrorCode)__FunctionDecl { using namespace poplar; -mod.method("PoplarErrorCodeToString", [](poplar::ErrorCode a) {return poplar::errorCodeToString(a);} ); } -// poplar::errorCodeFromString(std::string)__FunctionDecl +mod.method("PoplarErrorCodeToString", [](ErrorCode a) {return poplar::errorCodeToString(a);} ); } +// poplar::errorCodeFromString(StringRef)__FunctionDecl { using namespace poplar; -mod.method("PoplarErrorCodeFromString", [](std::string a) {return poplar::errorCodeFromString(a);} ); } +mod.method("PoplarErrorCodeFromString", [](StringRef a) {return poplar::errorCodeFromString(a);} ); } // poplar::ErrorLocation::getTile()__CXXMethod { using namespace poplar; JLErrorLocation.method("ErrorLocationGetTile", [](poplar::ErrorLocation& cl) {return cl.getTile();}); } -// poplar::ErrorLocation::ErrorLocation(const poplar::ErrorLocation &)__CXXConstructor +// poplar::ErrorLocation::ErrorLocation(const ErrorLocation &)__CXXConstructor { using namespace poplar; -JLErrorLocation.constructor(); +JLErrorLocation.constructor(); } // poplar::poplar_error::poplar_error(const std::string &)__CXXConstructor { using namespace poplar; @@ -1153,9 +1160,9 @@ JLPoplar_error.constructor(); { using namespace poplar; JLPoplar_error.constructor(); } -// poplar::poplar_error::attachSourceLocation(const poplar::DebugContext &)__CXXMethod +// poplar::poplar_error::attachSourceLocation(const DebugContext &)__CXXMethod { using namespace poplar; -JLPoplar_error.method("Poplar_errorAttachSourceLocation", [](poplar::poplar_error& cl, std::string a) {return cl.attachSourceLocation(a);}); +JLPoplar_error.method("Poplar_errorAttachSourceLocation", [](poplar::poplar_error& cl, const DebugContext & a) {return cl.attachSourceLocation(a);}); } // poplar::poplar_error::what()__CXXMethod { using namespace poplar; @@ -1417,13 +1424,13 @@ mod.set_const("PoplarRecoveryActionPoplarFULL_RESET", poplar::RecoveryAction::FU { using namespace poplar; JLRecoverable_runtime_error.method("Recoverable_runtime_errorGetRecoveryAction", [](poplar::recoverable_runtime_error& cl) {return cl.getRecoveryAction();}); } -// poplar::recoverable_runtime_error::recoverable_runtime_error(poplar::RecoveryAction, const std::string &)__CXXConstructor +// poplar::recoverable_runtime_error::recoverable_runtime_error(RecoveryAction, const std::string &)__CXXConstructor { using namespace poplar; -JLRecoverable_runtime_error.constructor(); +JLRecoverable_runtime_error.constructor(); } -// poplar::recoverable_runtime_error::recoverable_runtime_error(poplar::RecoveryAction, const char *)__CXXConstructor +// poplar::recoverable_runtime_error::recoverable_runtime_error(RecoveryAction, const char *)__CXXConstructor { using namespace poplar; -JLRecoverable_runtime_error.constructor(); +JLRecoverable_runtime_error.constructor(); } // poplar::unrecoverable_runtime_error::unrecoverable_runtime_error(const std::string &)__CXXConstructor { using namespace poplar; @@ -1481,9 +1488,9 @@ JLTypeTraits.method("TypeTraitsRequiresMetadata<>", [](poplar::TypeTraits& cl) { } // poplar::UpsampleMethod::REPEAT__EnumConstantDecl mod.set_const("PoplarUpsampleMethodPoplarREPEAT", poplar::UpsampleMethod::REPEAT); -// poplar::Tensor::Tensor(const poplar::Tensor &)__CXXConstructor +// poplar::Tensor::Tensor(const Tensor &)__CXXConstructor { using namespace poplar; -JLTensor.constructor(); +JLTensor.constructor(); } // poplar::Tensor::elementType()__CXXMethod { using namespace poplar; @@ -1497,19 +1504,19 @@ JLTensor.method("TensorSlice", [](poplar::Tensor& cl, std::size_t a, std::size_t { using namespace poplar; JLTensor.method("TensorSlice", [](poplar::Tensor& cl, std::size_t a, std::size_t b) {return cl.slice(a, b);}); } -// poplar::Tensor::slice(const poplar::Interval &, unsigned int)__CXXMethod +// poplar::Tensor::slice(const Interval &, unsigned int)__CXXMethod { using namespace poplar; -JLTensor.method("TensorSlice", [](poplar::Tensor& cl, const poplar::Interval & a) {return cl.slice(a);}); -JLTensor.method("TensorSlice", [](poplar::Tensor& cl, const poplar::Interval & a, unsigned int b) {return cl.slice(a, b);}); +JLTensor.method("TensorSlice", [](poplar::Tensor& cl, const Interval & a) {return cl.slice(a);}); +JLTensor.method("TensorSlice", [](poplar::Tensor& cl, const Interval & a, unsigned int b) {return cl.slice(a, b);}); } // poplar::Tensor::slice(ArrayRef, ArrayRef)__CXXMethod { using namespace poplar; JLTensor.method("TensorSlice", [](poplar::Tensor& cl, jlcxx::ArrayRef a, jlcxx::ArrayRef b) {return cl.slice(jlcxxToPoplar(a), jlcxxToPoplar(b));}); } -// poplar::Tensor::slices(ArrayRef, unsigned int)__CXXMethod +// poplar::Tensor::slices(ArrayRef, unsigned int)__CXXMethod { using namespace poplar; -JLTensor.method("TensorSlices", [](poplar::Tensor& cl, ArrayRef a) {return cl.slices(a);}); -JLTensor.method("TensorSlices", [](poplar::Tensor& cl, ArrayRef a, unsigned int b) {return cl.slices(a, b);}); +JLTensor.method("TensorSlices", [](poplar::Tensor& cl, jlcxx::ArrayRef a) {return cl.slices(jlcxxToPoplar(a));}); +JLTensor.method("TensorSlices", [](poplar::Tensor& cl, jlcxx::ArrayRef a, unsigned int b) {return cl.slices(jlcxxToPoplar(a), b);}); } // poplar::Tensor::slices(const std::vector> &, unsigned int)__CXXMethod { using namespace poplar; @@ -1570,17 +1577,17 @@ JLTensor.method("TensorTranspose", [](poplar::Tensor& cl) {return cl.transpose() { using namespace poplar; JLTensor.method("TensorSubSample", [](poplar::Tensor& cl, unsigned int a, unsigned int b) {return cl.subSample(a, b);}); } -// poplar::Tensor::upsample(unsigned int, unsigned int, poplar::UpsampleMethod)__CXXMethod +// poplar::Tensor::upsample(unsigned int, unsigned int, UpsampleMethod)__CXXMethod { using namespace poplar; -JLTensor.method("TensorUpsample", [](poplar::Tensor& cl, unsigned int a, unsigned int b, poplar::UpsampleMethod c) {return cl.upsample(a, b, c);}); +JLTensor.method("TensorUpsample", [](poplar::Tensor& cl, unsigned int a, unsigned int b, UpsampleMethod c) {return cl.upsample(a, b, c);}); } // poplar::Tensor::broadcast(unsigned int, unsigned int)__CXXMethod { using namespace poplar; JLTensor.method("TensorBroadcast", [](poplar::Tensor& cl, unsigned int a, unsigned int b) {return cl.broadcast(a, b);}); } -// poplar::Tensor::reinterpret(const poplar::Type &)__CXXMethod +// poplar::Tensor::reinterpret(const Type &)__CXXMethod { using namespace poplar; -JLTensor.method("TensorReinterpret", [](poplar::Tensor& cl, const poplar::Type & a) {return cl.reinterpret(a);}); +JLTensor.method("TensorReinterpret", [](poplar::Tensor& cl, const Type & a) {return cl.reinterpret(a);}); } // poplar::Tensor::reverse(unsigned int)__CXXMethod { using namespace poplar; @@ -1626,9 +1633,9 @@ JLTensor.method("TensorGetContiguousRegions", [](poplar::Tensor& cl) {return cl. { using namespace poplar; JLTensor.method("TensorGetVarRegions", [](poplar::Tensor& cl) {return cl.getVarRegions();}); } -// poplar::Tensor::intersectsWith(const poplar::Tensor &)__CXXMethod +// poplar::Tensor::intersectsWith(const Tensor &)__CXXMethod { using namespace poplar; -JLTensor.method("TensorIntersectsWith", [](poplar::Tensor& cl, const poplar::Tensor & a) {return cl.intersectsWith(a);}); +JLTensor.method("TensorIntersectsWith", [](poplar::Tensor& cl, const Tensor & a) {return cl.intersectsWith(a);}); } // poplar::Tensor::shapeToString()__CXXMethod { using namespace poplar; @@ -1662,210 +1669,210 @@ JLTensor.method("TensorGetMetadata", [](poplar::Tensor& cl) {return cl.getMetada { using namespace poplar; JLTensor.method("TensorHasMetadata", [](poplar::Tensor& cl) {return cl.hasMetadata();}); } -// poplar::concat(ArrayRef, unsigned int)__FunctionDecl +// poplar::concat(ArrayRef, unsigned int)__FunctionDecl { using namespace poplar; -mod.method("PoplarConcat", [](ArrayRef a, unsigned int b) {return poplar::concat(a, b);} ); } -// poplar::concat(const poplar::Tensor &, const poplar::Tensor &, unsigned int)__FunctionDecl +mod.method("PoplarConcat", [](jlcxx::ArrayRef a, unsigned int b) {return poplar::concat(jlcxxToPoplar(a), b);} ); } +// poplar::concat(const Tensor &, const Tensor &, unsigned int)__FunctionDecl { using namespace poplar; -mod.method("PoplarConcat", [](const poplar::Tensor & a, const poplar::Tensor & b, unsigned int c) {return poplar::concat(a, b, c);} ); } -// poplar::append(const poplar::Tensor &, const poplar::Tensor &, unsigned int)__FunctionDecl +mod.method("PoplarConcat", [](const Tensor & a, const Tensor & b, unsigned int c) {return poplar::concat(a, b, c);} ); } +// poplar::append(const Tensor &, const Tensor &, unsigned int)__FunctionDecl { using namespace poplar; -mod.method("PoplarAppend", [](const poplar::Tensor & a, const poplar::Tensor & b, unsigned int c) {return poplar::append(a, b, c);} ); } -// poplar::append(const poplar::Tensor &, const poplar::Tensor &)__FunctionDecl +mod.method("PoplarAppend", [](const Tensor & a, const Tensor & b, unsigned int c) {return poplar::append(a, b, c);} ); } +// poplar::append(const Tensor &, const Tensor &)__FunctionDecl { using namespace poplar; -mod.method("PoplarAppend", [](const poplar::Tensor & a, const poplar::Tensor & b) {return poplar::append(a, b);} ); } -// poplar::program::Program::Program(const poplar::program::Program &)__CXXConstructor +mod.method("PoplarAppend", [](const Tensor & a, const Tensor & b) {return poplar::append(a, b);} ); } +// poplar::program::Program::Program(const Program &)__CXXConstructor { using namespace poplar::program; -JLProgramProgram.constructor(); +JLProgramProgram.constructor(); } // poplar::program::Program::isEmpty()__CXXMethod { using namespace poplar::program; JLProgramProgram.method("ProgramProgramIsEmpty", [](poplar::program::Program& cl) {return cl.isEmpty();}); } -// poplar::program::Execute::Execute(poplar::ComputeSet, const poplar::DebugContext &)__CXXConstructor +// poplar::program::Execute::Execute(ComputeSet, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramExecute.constructor(); -JLProgramExecute.constructor(); +JLProgramExecute.constructor(); +JLProgramExecute.constructor(); } -// poplar::program::Execute::Execute(poplar::ComputeSet, poplar::Tensor, const poplar::DebugContext &)__CXXConstructor +// poplar::program::Execute::Execute(ComputeSet, Tensor, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramExecute.constructor(); -JLProgramExecute.constructor(); +JLProgramExecute.constructor(); +JLProgramExecute.constructor(); } -// poplar::program::Sequence::add(const poplar::program::Program &)__CXXMethod +// poplar::program::Sequence::add(const Program &)__CXXMethod { using namespace poplar::program; -JLProgramSequence.method("ProgramSequenceAdd", [](poplar::program::Sequence& cl, const poplar::program::Program & a) {return cl.add(a);}); +JLProgramSequence.method("ProgramSequenceAdd", [](poplar::program::Sequence& cl, const Program & a) {return cl.add(a);}); } -// poplar::program::Repeat::Repeat(unsigned int, const poplar::program::Program &, const poplar::DebugContext &)__CXXConstructor +// poplar::program::Repeat::Repeat(unsigned int, const Program &, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramRepeat.constructor(); -JLProgramRepeat.constructor(); +JLProgramRepeat.constructor(); +JLProgramRepeat.constructor(); } -// poplar::program::RepeatWhileFalse::RepeatWhileFalse(const poplar::program::Program &, poplar::Tensor, const poplar::program::Program &, const poplar::DebugContext &)__CXXConstructor +// poplar::program::RepeatWhileFalse::RepeatWhileFalse(const Program &, Tensor, const Program &, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramRepeatWhileFalse.constructor(); -JLProgramRepeatWhileFalse.constructor(); +JLProgramRepeatWhileFalse.constructor(); +JLProgramRepeatWhileFalse.constructor(); } -// poplar::program::RepeatWhileTrue::RepeatWhileTrue(const poplar::program::Program &, poplar::Tensor, const poplar::program::Program &, const poplar::DebugContext &)__CXXConstructor +// poplar::program::RepeatWhileTrue::RepeatWhileTrue(const Program &, Tensor, const Program &, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramRepeatWhileTrue.constructor(); -JLProgramRepeatWhileTrue.constructor(); +JLProgramRepeatWhileTrue.constructor(); +JLProgramRepeatWhileTrue.constructor(); } -// poplar::program::Loop::Loop(const poplar::program::Program &, const poplar::DebugContext &)__CXXConstructor +// poplar::program::Loop::Loop(const Program &, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramLoop.constructor(); -JLProgramLoop.constructor(); +JLProgramLoop.constructor(); +JLProgramLoop.constructor(); } -// poplar::program::If::If(poplar::Tensor, const poplar::program::Program &, const poplar::program::Program &, const poplar::DebugContext &)__CXXConstructor +// poplar::program::If::If(Tensor, const Program &, const Program &, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramIf.constructor(); -JLProgramIf.constructor(); +JLProgramIf.constructor(); +JLProgramIf.constructor(); } -// poplar::program::Switch::Switch(poplar::Tensor, const std::vector> &, const poplar::DebugContext &)__CXXConstructor +// poplar::program::Switch::Switch(Tensor, const std::vector> &, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramSwitch.constructor> &>(); -JLProgramSwitch.constructor> &, std::string>(); +JLProgramSwitch.constructor> &>(); +JLProgramSwitch.constructor> &, const DebugContext &>(); } -// poplar::program::Switch::Switch(poplar::Tensor, const std::vector> &, const poplar::program::Program &, const poplar::DebugContext &)__CXXConstructor +// poplar::program::Switch::Switch(Tensor, const std::vector> &, const Program &, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramSwitch.constructor> &, const poplar::program::Program &>(); -JLProgramSwitch.constructor> &, const poplar::program::Program &, std::string>(); +JLProgramSwitch.constructor> &, const Program &>(); +JLProgramSwitch.constructor> &, const Program &, const DebugContext &>(); } -// poplar::program::Switch::Switch(poplar::Tensor, const poplar::DebugContext &)__CXXConstructor +// poplar::program::Switch::Switch(Tensor, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramSwitch.constructor(); -JLProgramSwitch.constructor(); +JLProgramSwitch.constructor(); +JLProgramSwitch.constructor(); } -// poplar::program::Switch::Switch(poplar::Tensor, const poplar::program::Program &, const poplar::DebugContext &)__CXXConstructor +// poplar::program::Switch::Switch(Tensor, const Program &, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramSwitch.constructor(); -JLProgramSwitch.constructor(); +JLProgramSwitch.constructor(); +JLProgramSwitch.constructor(); } -// poplar::program::Switch::add(std::int32_t, const poplar::program::Program &)__CXXMethod +// poplar::program::Switch::add(std::int32_t, const Program &)__CXXMethod { using namespace poplar::program; -JLProgramSwitch.method("ProgramSwitchAdd", [](poplar::program::Switch& cl, std::int32_t a, const poplar::program::Program & b) {return cl.add(a, b);}); +JLProgramSwitch.method("ProgramSwitchAdd", [](poplar::program::Switch& cl, std::int32_t a, const Program & b) {return cl.add(a, b);}); } -// poplar::program::Switch::switchWithBoundsChecking(poplar::Tensor, const std::vector> &, const poplar::DebugContext &)__CXXMethod +// poplar::program::Switch::switchWithBoundsChecking(Tensor, const std::vector> &, const DebugContext &)__CXXMethod { using namespace poplar::program; -JLProgramSwitch.method("ProgramSwitchSwitchWithBoundsChecking", [](poplar::program::Switch& cl, poplar::Tensor a, const std::vector> & b) {return cl.switchWithBoundsChecking(a, b);}); -JLProgramSwitch.method("ProgramSwitchSwitchWithBoundsChecking", [](poplar::program::Switch& cl, poplar::Tensor a, const std::vector> & b, std::string c) {return cl.switchWithBoundsChecking(a, b, c);}); +JLProgramSwitch.method("ProgramSwitchSwitchWithBoundsChecking", [](poplar::program::Switch& cl, Tensor a, const std::vector> & b) {return cl.switchWithBoundsChecking(a, b);}); +JLProgramSwitch.method("ProgramSwitchSwitchWithBoundsChecking", [](poplar::program::Switch& cl, Tensor a, const std::vector> & b, const DebugContext & c) {return cl.switchWithBoundsChecking(a, b, c);}); } -// poplar::program::Switch::switchWithUnreachableDefault(poplar::Tensor, const poplar::DebugContext &)__CXXMethod +// poplar::program::Switch::switchWithUnreachableDefault(Tensor, const DebugContext &)__CXXMethod { using namespace poplar::program; -JLProgramSwitch.method("ProgramSwitchSwitchWithUnreachableDefault", [](poplar::program::Switch& cl, poplar::Tensor a) {return cl.switchWithUnreachableDefault(a);}); -JLProgramSwitch.method("ProgramSwitchSwitchWithUnreachableDefault", [](poplar::program::Switch& cl, poplar::Tensor a, std::string b) {return cl.switchWithUnreachableDefault(a, b);}); +JLProgramSwitch.method("ProgramSwitchSwitchWithUnreachableDefault", [](poplar::program::Switch& cl, Tensor a) {return cl.switchWithUnreachableDefault(a);}); +JLProgramSwitch.method("ProgramSwitchSwitchWithUnreachableDefault", [](poplar::program::Switch& cl, Tensor a, const DebugContext & b) {return cl.switchWithUnreachableDefault(a, b);}); } -// poplar::program::Copy::Copy(poplar::Tensor, poplar::Tensor, bool, const poplar::DebugContext &)__CXXConstructor +// poplar::program::Copy::Copy(Tensor, Tensor, bool, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramCopy.constructor(); -JLProgramCopy.constructor(); -JLProgramCopy.constructor(); +JLProgramCopy.constructor(); +JLProgramCopy.constructor(); +JLProgramCopy.constructor(); } -// poplar::program::Copy::Copy(const poplar::DataStream &, poplar::Tensor, bool, const poplar::DebugContext &)__CXXConstructor +// poplar::program::Copy::Copy(const DataStream &, Tensor, bool, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramCopy.constructor(); -JLProgramCopy.constructor(); -JLProgramCopy.constructor(); +JLProgramCopy.constructor(); +JLProgramCopy.constructor(); +JLProgramCopy.constructor(); } -// poplar::program::Copy::Copy(poplar::Tensor, const poplar::DataStream &, bool, const poplar::DebugContext &)__CXXConstructor +// poplar::program::Copy::Copy(Tensor, const DataStream &, bool, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramCopy.constructor(); -JLProgramCopy.constructor(); -JLProgramCopy.constructor(); +JLProgramCopy.constructor(); +JLProgramCopy.constructor(); +JLProgramCopy.constructor(); } -// poplar::program::Copy::Copy(const poplar::RemoteBuffer &, poplar::Tensor, const poplar::DebugContext &)__CXXConstructor +// poplar::program::Copy::Copy(const RemoteBuffer &, Tensor, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramCopy.constructor(); -JLProgramCopy.constructor(); +JLProgramCopy.constructor(); +JLProgramCopy.constructor(); } -// poplar::program::Copy::Copy(const poplar::RemoteBuffer &, poplar::Tensor, poplar::Tensor, const poplar::DebugContext &)__CXXConstructor +// poplar::program::Copy::Copy(const RemoteBuffer &, Tensor, Tensor, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramCopy.constructor(); -JLProgramCopy.constructor(); +JLProgramCopy.constructor(); +JLProgramCopy.constructor(); } -// poplar::program::Copy::Copy(poplar::Tensor, const poplar::RemoteBuffer &, const poplar::DebugContext &)__CXXConstructor +// poplar::program::Copy::Copy(Tensor, const RemoteBuffer &, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramCopy.constructor(); -JLProgramCopy.constructor(); +JLProgramCopy.constructor(); +JLProgramCopy.constructor(); } -// poplar::program::Copy::Copy(poplar::Tensor, const poplar::RemoteBuffer &, poplar::Tensor, const poplar::DebugContext &)__CXXConstructor +// poplar::program::Copy::Copy(Tensor, const RemoteBuffer &, Tensor, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramCopy.constructor(); -JLProgramCopy.constructor(); +JLProgramCopy.constructor(); +JLProgramCopy.constructor(); } -// poplar::program::Copy::Copy(const poplar::FunctionBuffer &, const poplar::Function &, const poplar::DebugContext &)__CXXConstructor +// poplar::program::Copy::Copy(const FunctionBuffer &, const Function &, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramCopy.constructor(); -JLProgramCopy.constructor(); +JLProgramCopy.constructor(); +JLProgramCopy.constructor(); } -// poplar::program::CrossReplicaCopy::CrossReplicaCopy(poplar::Tensor, poplar::Tensor, std::map, const poplar::DebugContext &)__CXXConstructor +// poplar::program::CrossReplicaCopy::CrossReplicaCopy(Tensor, Tensor, std::map, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramCrossReplicaCopy.constructor>(); -JLProgramCrossReplicaCopy.constructor, std::string>(); +JLProgramCrossReplicaCopy.constructor>(); +JLProgramCrossReplicaCopy.constructor, const DebugContext &>(); } -// poplar::program::WriteUndef::WriteUndef(poplar::Tensor, const poplar::DebugContext &)__CXXConstructor +// poplar::program::WriteUndef::WriteUndef(Tensor, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramWriteUndef.constructor(); -JLProgramWriteUndef.constructor(); +JLProgramWriteUndef.constructor(); +JLProgramWriteUndef.constructor(); } -// poplar::program::AssumeEqualAcrossReplicas::AssumeEqualAcrossReplicas(poplar::Tensor, const poplar::DebugContext &)__CXXConstructor +// poplar::program::AssumeEqualAcrossReplicas::AssumeEqualAcrossReplicas(Tensor, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramAssumeEqualAcrossReplicas.constructor(); -JLProgramAssumeEqualAcrossReplicas.constructor(); +JLProgramAssumeEqualAcrossReplicas.constructor(); +JLProgramAssumeEqualAcrossReplicas.constructor(); } -// poplar::program::Block::Block(const poplar::program::Program &, const poplar::DebugContext &)__CXXConstructor +// poplar::program::Block::Block(const Program &, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramBlock.constructor(); -JLProgramBlock.constructor(); +JLProgramBlock.constructor(); +JLProgramBlock.constructor(); } -// poplar::program::Sync::Sync(poplar::SyncType, const poplar::DebugContext &)__CXXConstructor +// poplar::program::Sync::Sync(SyncType, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramSync.constructor(); -JLProgramSync.constructor(); +JLProgramSync.constructor(); +JLProgramSync.constructor(); } -// poplar::program::Call::Call(poplar::Function, const poplar::DebugContext &)__CXXConstructor +// poplar::program::Call::Call(Function, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramCall.constructor(); -JLProgramCall.constructor(); +JLProgramCall.constructor(); +JLProgramCall.constructor(); } -// poplar::program::Call::Call(poplar::HostFunction, ArrayRef, ArrayRef, const poplar::DebugContext &)__CXXConstructor +// poplar::program::Call::Call(HostFunction, ArrayRef, ArrayRef, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramCall.constructor, ArrayRef>(); -JLProgramCall.constructor, ArrayRef, std::string>(); +JLProgramCall.constructor, jlcxx::ArrayRef>(); +JLProgramCall.constructor, jlcxx::ArrayRef, const DebugContext &>(); } -// poplar::program::PrintTensor::PrintTensor(poplar::Tensor, const poplar::DebugContext &)__CXXConstructor +// poplar::program::PrintTensor::PrintTensor(Tensor, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramPrintTensor.constructor(); -JLProgramPrintTensor.constructor(); +JLProgramPrintTensor.constructor(); +JLProgramPrintTensor.constructor(); } -// poplar::program::PrintTensor::PrintTensor(std::string, poplar::Tensor, const poplar::DebugContext &)__CXXConstructor +// poplar::program::PrintTensor::PrintTensor(StringRef, Tensor, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramPrintTensor.constructor(); -JLProgramPrintTensor.constructor(); +JLProgramPrintTensor.constructor(); +JLProgramPrintTensor.constructor(); } -// poplar::program::ErrorProgram::ErrorProgram(std::string, poplar::Tensor, const poplar::DebugContext &)__CXXConstructor +// poplar::program::ErrorProgram::ErrorProgram(StringRef, Tensor, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramErrorProgram.constructor(); -JLProgramErrorProgram.constructor(); +JLProgramErrorProgram.constructor(); +JLProgramErrorProgram.constructor(); } -// poplar::program::Abort::Abort(const poplar::DebugContext &)__CXXConstructor +// poplar::program::Abort::Abort(const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramAbort.constructor(); +JLProgramAbort.constructor(); } -// poplar::program::Abort::Abort(const std::string &, const poplar::DebugContext &)__CXXConstructor +// poplar::program::Abort::Abort(const std::string &, const DebugContext &)__CXXConstructor { using namespace poplar::program; JLProgramAbort.constructor(); -JLProgramAbort.constructor(); +JLProgramAbort.constructor(); } -// poplar::program::AbortOnCondition::AbortOnCondition(poplar::Tensor, const poplar::DebugContext &)__CXXConstructor +// poplar::program::AbortOnCondition::AbortOnCondition(Tensor, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramAbortOnCondition.constructor(); -JLProgramAbortOnCondition.constructor(); +JLProgramAbortOnCondition.constructor(); +JLProgramAbortOnCondition.constructor(); } -// poplar::program::AbortOnCondition::AbortOnCondition(poplar::Tensor, const std::string &, const poplar::DebugContext &)__CXXConstructor +// poplar::program::AbortOnCondition::AbortOnCondition(Tensor, const std::string &, const DebugContext &)__CXXConstructor { using namespace poplar::program; -JLProgramAbortOnCondition.constructor(); -JLProgramAbortOnCondition.constructor(); +JLProgramAbortOnCondition.constructor(); +JLProgramAbortOnCondition.constructor(); } // poplar::TensorCloneMethod::PRESERVE_ORDER_AND_ALIASES__EnumConstantDecl mod.set_const("PoplarTensorCloneMethodPoplarPRESERVE_ORDER_AND_ALIASES", poplar::TensorCloneMethod::PRESERVE_ORDER_AND_ALIASES); @@ -1879,25 +1886,25 @@ mod.set_const("PoplarTensorCloneMethodPoplarGATHER_AND_PRESERVE_TILE_ORDER_AND_A mod.set_const("PoplarTensorCloneDuplicationMethodPoplarDUPLICATE_BY_OUTER_DIMENSION", poplar::TensorCloneDuplicationMethod::DUPLICATE_BY_OUTER_DIMENSION); // poplar::TensorCloneDuplicationMethod::DUPLICATE_BY_TILE_CONTIGUOUS_REGION__EnumConstantDecl mod.set_const("PoplarTensorCloneDuplicationMethodPoplarDUPLICATE_BY_TILE_CONTIGUOUS_REGION", poplar::TensorCloneDuplicationMethod::DUPLICATE_BY_TILE_CONTIGUOUS_REGION); -// poplar::TensorRearranger::TensorRearranger(const poplar::TensorRearranger &)__CXXConstructor +// poplar::TensorRearranger::TensorRearranger(const TensorRearranger &)__CXXConstructor { using namespace poplar; -JLTensorRearranger.constructor(); +JLTensorRearranger.constructor(); } -// poplar::TensorRearranger::rearrange(const poplar::Tensor &)__CXXMethod +// poplar::TensorRearranger::rearrange(const Tensor &)__CXXMethod { using namespace poplar; -JLTensorRearranger.method("TensorRearrangerRearrange", [](poplar::TensorRearranger& cl, const poplar::Tensor & a) {return cl.rearrange(a);}); +JLTensorRearranger.method("TensorRearrangerRearrange", [](poplar::TensorRearranger& cl, const Tensor & a) {return cl.rearrange(a);}); } -// poplar::TensorRearranger::undoRearrangement(const poplar::Tensor &)__CXXMethod +// poplar::TensorRearranger::undoRearrangement(const Tensor &)__CXXMethod { using namespace poplar; -JLTensorRearranger.method("TensorRearrangerUndoRearrangement", [](poplar::TensorRearranger& cl, const poplar::Tensor & a) {return cl.undoRearrangement(a);}); +JLTensorRearranger.method("TensorRearrangerUndoRearrangement", [](poplar::TensorRearranger& cl, const Tensor & a) {return cl.undoRearrangement(a);}); } -// poplar::TensorRearranger::rearrange(ArrayRef)__CXXMethod +// poplar::TensorRearranger::rearrange(ArrayRef)__CXXMethod { using namespace poplar; -JLTensorRearranger.method("TensorRearrangerRearrange", [](poplar::TensorRearranger& cl, ArrayRef a) {return cl.rearrange(a);}); +JLTensorRearranger.method("TensorRearrangerRearrange", [](poplar::TensorRearranger& cl, jlcxx::ArrayRef a) {return cl.rearrange(jlcxxToPoplar(a));}); } -// poplar::TensorRearranger::undoRearrangement(ArrayRef)__CXXMethod +// poplar::TensorRearranger::undoRearrangement(ArrayRef)__CXXMethod { using namespace poplar; -JLTensorRearranger.method("TensorRearrangerUndoRearrangement", [](poplar::TensorRearranger& cl, ArrayRef a) {return cl.undoRearrangement(a);}); +JLTensorRearranger.method("TensorRearrangerUndoRearrangement", [](poplar::TensorRearranger& cl, jlcxx::ArrayRef a) {return cl.undoRearrangement(jlcxxToPoplar(a));}); } // poplar::TensorRearranger::valid()__CXXMethod { using namespace poplar; @@ -1911,21 +1918,21 @@ mod.set_const("PoplarVariableMappingMethodPoplarLINEAR", poplar::VariableMapping { using namespace poplar; JLVariableRef.constructor(); } -// poplar::VariableRef::VariableRef(const poplar::VariableRef &)__CXXConstructor +// poplar::VariableRef::VariableRef(const VariableRef &)__CXXConstructor { using namespace poplar; -JLVariableRef.constructor(); +JLVariableRef.constructor(); } // poplar::VariableRef::hash()__CXXMethod { using namespace poplar; JLVariableRef.method("VariableRefHash", [](poplar::VariableRef& cl) {return cl.hash();}); } -// poplar::VariableInterval::VariableInterval(poplar::VariableRef, poplar::Interval)__CXXConstructor +// poplar::VariableInterval::VariableInterval(VariableRef, Interval)__CXXConstructor { using namespace poplar; -JLVariableInterval.constructor(); +JLVariableInterval.constructor(); } -// poplar::VariableInterval::VariableInterval(const poplar::VariableInterval &)__CXXConstructor +// poplar::VariableInterval::VariableInterval(const VariableInterval &)__CXXConstructor { using namespace poplar; -JLVariableInterval.constructor(); +JLVariableInterval.constructor(); } // poplar::FieldData::rank()__CXXMethod { using namespace poplar; @@ -1961,378 +1968,378 @@ mod.method("PoplarVersionString", []() {return poplar::versionString();} ); } // poplar::packageHash()__FunctionDecl { using namespace poplar; mod.method("PoplarPackageHash", []() {return poplar::packageHash();} ); } -// poplar::Graph::Graph(const poplar::Target &, poplar::replication_factor)__CXXConstructor +// poplar::Graph::Graph(const Target &, replication_factor)__CXXConstructor { using namespace poplar; -JLGraph.constructor(); -JLGraph.constructor(); +JLGraph.constructor(); +JLGraph.constructor(); } -// poplar::Graph::Graph(const poplar::Device &, poplar::replication_factor)__CXXConstructor +// poplar::Graph::Graph(const Device &, replication_factor)__CXXConstructor { using namespace poplar; -JLGraph.constructor(); -JLGraph.constructor(); +JLGraph.constructor(); +JLGraph.constructor(); } // poplar::Graph::getTarget()__CXXMethod { using namespace poplar; JLGraph.method("GraphGetTarget", [](poplar::Graph& cl) {return cl.getTarget();}); } -// poplar::Graph::addCodelets(std::string, poplar::CodeletFileType, std::string, std::string)__CXXMethod +// poplar::Graph::addCodelets(StringRef, CodeletFileType, StringRef, StringRef)__CXXMethod { using namespace poplar; -JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, std::string a) {return cl.addCodelets(a);}); -JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, std::string a, poplar::CodeletFileType b) {return cl.addCodelets(a, b);}); -JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, std::string a, poplar::CodeletFileType b, std::string c) {return cl.addCodelets(a, b, c);}); -JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, std::string a, poplar::CodeletFileType b, std::string c, std::string d) {return cl.addCodelets(a, b, c, d);}); +JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, StringRef a) {return cl.addCodelets(a);}); +JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, StringRef a, CodeletFileType b) {return cl.addCodelets(a, b);}); +JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, StringRef a, CodeletFileType b, StringRef c) {return cl.addCodelets(a, b, c);}); +JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, StringRef a, CodeletFileType b, StringRef c, StringRef d) {return cl.addCodelets(a, b, c, d);}); } -// poplar::Graph::addCodelets(ArrayRef, std::string, std::string)__CXXMethod +// poplar::Graph::addCodelets(ArrayRef, StringRef, StringRef)__CXXMethod { using namespace poplar; JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, ArrayRef a) {return cl.addCodelets(a);}); -JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, ArrayRef a, std::string b) {return cl.addCodelets(a, b);}); -JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, ArrayRef a, std::string b, std::string c) {return cl.addCodelets(a, b, c);}); +JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, ArrayRef a, StringRef b) {return cl.addCodelets(a, b);}); +JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, ArrayRef a, StringRef b, StringRef c) {return cl.addCodelets(a, b, c);}); } -// poplar::Graph::addCodelets(std::stringstream &, std::string, poplar::CodeletFileType, std::string)__CXXMethod +// poplar::Graph::addCodelets(std::stringstream &, StringRef, CodeletFileType, StringRef)__CXXMethod { using namespace poplar; JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, std::stringstream & a) {return cl.addCodelets(a);}); -JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, std::stringstream & a, std::string b) {return cl.addCodelets(a, b);}); -JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, std::stringstream & a, std::string b, poplar::CodeletFileType c) {return cl.addCodelets(a, b, c);}); -JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, std::stringstream & a, std::string b, poplar::CodeletFileType c, std::string d) {return cl.addCodelets(a, b, c, d);}); +JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, std::stringstream & a, StringRef b) {return cl.addCodelets(a, b);}); +JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, std::stringstream & a, StringRef b, CodeletFileType c) {return cl.addCodelets(a, b, c);}); +JLGraph.method("GraphAddCodelets", [](poplar::Graph& cl, std::stringstream & a, StringRef b, CodeletFileType c, StringRef d) {return cl.addCodelets(a, b, c, d);}); } -// poplar::Graph::ConnectionDesc::ConnectionDesc(std::string, poplar::Tensor)__CXXConstructor +// poplar::Graph::ConnectionDesc::ConnectionDesc(StringRef, Tensor)__CXXConstructor { using namespace poplar; -JLGraphConnectionDesc.constructor(); +JLGraphConnectionDesc.constructor(); } -// poplar::Graph::ConnectionDesc::ConnectionDesc(std::string, ArrayRef)__CXXConstructor +// poplar::Graph::ConnectionDesc::ConnectionDesc(StringRef, ArrayRef)__CXXConstructor { using namespace poplar; -JLGraphConnectionDesc.constructor>(); +JLGraphConnectionDesc.constructor>(); } -// poplar::Graph::addVertex(poplar::ComputeSet, std::string)__CXXMethod +// poplar::Graph::addVertex(ComputeSet, StringRef)__CXXMethod { using namespace poplar; -JLGraph.method("GraphAddVertex", [](poplar::Graph& cl, poplar::ComputeSet a, std::string b) {return cl.addVertex(a, b);}); +JLGraph.method("GraphAddVertex", [](poplar::Graph& cl, ComputeSet a, StringRef b) {return cl.addVertex(a, b);}); } -// poplar::Graph::addVertex(poplar::ComputeSet, std::string, ArrayRef)__CXXMethod +// poplar::Graph::addVertex(ComputeSet, StringRef, ArrayRef)__CXXMethod { using namespace poplar; -JLGraph.method("GraphAddVertex", [](poplar::Graph& cl, poplar::ComputeSet a, std::string b, ArrayRef c) {return cl.addVertex(a, b, c);}); +JLGraph.method("GraphAddVertex", [](poplar::Graph& cl, ComputeSet a, StringRef b, jlcxx::ArrayRef c) {return cl.addVertex(a, b, jlcxxToPoplar(c));}); } -// poplar::Graph::addExternalExchangeVertex(poplar::ComputeSet, std::string, unsigned int, bool, bool)__CXXMethod +// poplar::Graph::addExternalExchangeVertex(ComputeSet, StringRef, unsigned int, bool, bool)__CXXMethod { using namespace poplar; -JLGraph.method("GraphAddExternalExchangeVertex", [](poplar::Graph& cl, poplar::ComputeSet a, std::string b, unsigned int c, bool d, bool e) {return cl.addExternalExchangeVertex(a, b, c, d, e);}); +JLGraph.method("GraphAddExternalExchangeVertex", [](poplar::Graph& cl, ComputeSet a, StringRef b, unsigned int c, bool d, bool e) {return cl.addExternalExchangeVertex(a, b, c, d, e);}); } -// poplar::Graph::addVariable(const poplar::Type &, ArrayRef, const poplar::DebugContext &)__CXXMethod +// poplar::Graph::addVariable(const Type &, ArrayRef, const DebugContext &)__CXXMethod { using namespace poplar; -JLGraph.method("GraphAddVariable", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b) {return cl.addVariable(a, jlcxxToPoplar(b));}); -JLGraph.method("GraphAddVariable", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, std::string c) {return cl.addVariable(a, jlcxxToPoplar(b), c);}); +JLGraph.method("GraphAddVariable", [](poplar::Graph& cl, const Type & a, jlcxx::ArrayRef b) {return cl.addVariable(a, jlcxxToPoplar(b));}); +JLGraph.method("GraphAddVariable", [](poplar::Graph& cl, const Type & a, jlcxx::ArrayRef b, const DebugContext & c) {return cl.addVariable(a, jlcxxToPoplar(b), c);}); } -// poplar::Graph::addVariable(const poplar::Type &, const poplar::Tensor &, ArrayRef, const poplar::DebugContext &)__CXXMethod +// poplar::Graph::addVariable(const Type &, const Tensor &, ArrayRef, const DebugContext &)__CXXMethod { using namespace poplar; -JLGraph.method("GraphAddVariable", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c) {return cl.addVariable(a, b, jlcxxToPoplar(c));}); -JLGraph.method("GraphAddVariable", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, std::string d) {return cl.addVariable(a, b, jlcxxToPoplar(c), d);}); +JLGraph.method("GraphAddVariable", [](poplar::Graph& cl, const Type & a, const Tensor & b, jlcxx::ArrayRef c) {return cl.addVariable(a, b, jlcxxToPoplar(c));}); +JLGraph.method("GraphAddVariable", [](poplar::Graph& cl, const Type & a, const Tensor & b, jlcxx::ArrayRef c, const DebugContext & d) {return cl.addVariable(a, b, jlcxxToPoplar(c), d);}); } -// poplar::Graph::addVariable(const poplar::Type &, ArrayRef, poplar::VariableMappingMethod, const poplar::DebugContext &)__CXXMethod +// poplar::Graph::addVariable(const Type &, ArrayRef, VariableMappingMethod, const DebugContext &)__CXXMethod { using namespace poplar; -JLGraph.method("GraphAddVariable", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, poplar::VariableMappingMethod c) {return cl.addVariable(a, jlcxxToPoplar(b), c);}); -JLGraph.method("GraphAddVariable", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, poplar::VariableMappingMethod c, std::string d) {return cl.addVariable(a, jlcxxToPoplar(b), c, d);}); +JLGraph.method("GraphAddVariable", [](poplar::Graph& cl, const Type & a, jlcxx::ArrayRef b, VariableMappingMethod c) {return cl.addVariable(a, jlcxxToPoplar(b), c);}); +JLGraph.method("GraphAddVariable", [](poplar::Graph& cl, const Type & a, jlcxx::ArrayRef b, VariableMappingMethod c, const DebugContext & d) {return cl.addVariable(a, jlcxxToPoplar(b), c, d);}); } -// poplar::Graph::addVariable(const poplar::Type &, const poplar::Tensor &, ArrayRef, poplar::VariableMappingMethod, const poplar::DebugContext &)__CXXMethod +// poplar::Graph::addVariable(const Type &, const Tensor &, ArrayRef, VariableMappingMethod, const DebugContext &)__CXXMethod { using namespace poplar; -JLGraph.method("GraphAddVariable", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, poplar::VariableMappingMethod d) {return cl.addVariable(a, b, jlcxxToPoplar(c), d);}); -JLGraph.method("GraphAddVariable", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, poplar::VariableMappingMethod d, std::string e) {return cl.addVariable(a, b, jlcxxToPoplar(c), d, e);}); +JLGraph.method("GraphAddVariable", [](poplar::Graph& cl, const Type & a, const Tensor & b, jlcxx::ArrayRef c, VariableMappingMethod d) {return cl.addVariable(a, b, jlcxxToPoplar(c), d);}); +JLGraph.method("GraphAddVariable", [](poplar::Graph& cl, const Type & a, const Tensor & b, jlcxx::ArrayRef c, VariableMappingMethod d, const DebugContext & e) {return cl.addVariable(a, b, jlcxxToPoplar(c), d, e);}); } -// poplar::Graph::addExternalVariable(const poplar::Type &, ArrayRef, std::string, const poplar::DebugContext &)__CXXMethod +// poplar::Graph::addExternalVariable(const Type &, ArrayRef, StringRef, const DebugContext &)__CXXMethod { using namespace poplar; -JLGraph.method("GraphAddExternalVariable", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, std::string c) {return cl.addExternalVariable(a, jlcxxToPoplar(b), c);}); -JLGraph.method("GraphAddExternalVariable", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, std::string c, std::string d) {return cl.addExternalVariable(a, jlcxxToPoplar(b), c, d);}); +JLGraph.method("GraphAddExternalVariable", [](poplar::Graph& cl, const Type & a, jlcxx::ArrayRef b, StringRef c) {return cl.addExternalVariable(a, jlcxxToPoplar(b), c);}); +JLGraph.method("GraphAddExternalVariable", [](poplar::Graph& cl, const Type & a, jlcxx::ArrayRef b, StringRef c, const DebugContext & d) {return cl.addExternalVariable(a, jlcxxToPoplar(b), c, d);}); } -// poplar::Graph::addConstant(const poplar::Type &, const poplar::Tensor &, ArrayRef, ArrayRef, const poplar::DebugContext &)__FunctionTemplate +// poplar::Graph::addConstant(const Type &, const Tensor &, ArrayRef, ArrayRef, const DebugContext &)__FunctionTemplate { using namespace poplar; -JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d));}); -JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d, std::string e) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d), e);}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const Type & a, const Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d));}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const Type & a, const Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d, const DebugContext & e) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d), e);}); }{ using namespace poplar; -JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d));}); -JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d, std::string e) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d), e);}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const Type & a, const Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d));}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const Type & a, const Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d, const DebugContext & e) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d), e);}); }{ using namespace poplar; -JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d));}); -JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d, std::string e) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d), e);}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const Type & a, const Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d));}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const Type & a, const Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d, const DebugContext & e) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d), e);}); }{ using namespace poplar; -JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d));}); -JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d, std::string e) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d), e);}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const Type & a, const Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d));}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const Type & a, const Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d, const DebugContext & e) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d), e);}); }{ using namespace poplar; -JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d));}); -JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d, std::string e) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d), e);}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const Type & a, const Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d));}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const Type & a, const Tensor & b, jlcxx::ArrayRef c, jlcxx::ArrayRef d, const DebugContext & e) {return cl.addConstant(a, b, jlcxxToPoplar(c), jlcxxToPoplar(d), e);}); } -// poplar::Graph::addConstant(const poplar::Type &, ArrayRef, ArrayRef, const poplar::DebugContext &)__FunctionTemplate +// poplar::Graph::addConstant(const Type &, ArrayRef, ArrayRef, const DebugContext &)__FunctionTemplate { using namespace poplar; -JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c));}); -JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c, std::string d) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c), d);}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c));}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c, const DebugContext & d) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c), d);}); }{ using namespace poplar; -JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c));}); -JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c, std::string d) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c), d);}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c));}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c, const DebugContext & d) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c), d);}); }{ using namespace poplar; -JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c));}); -JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c, std::string d) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c), d);}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c));}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c, const DebugContext & d) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c), d);}); }{ using namespace poplar; -JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c));}); -JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c, std::string d) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c), d);}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c));}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c, const DebugContext & d) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c), d);}); }{ using namespace poplar; -JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c));}); -JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c, std::string d) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c), d);}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c));}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const Type & a, jlcxx::ArrayRef b, jlcxx::ArrayRef c, const DebugContext & d) {return cl.addConstant(a, jlcxxToPoplar(b), jlcxxToPoplar(c), d);}); } -// poplar::Graph::addConstant(const poplar::Type &, ArrayRef, const void *, const poplar::TypeTraits &, bool, const poplar::DebugContext &)__CXXMethod +// poplar::Graph::addConstant(const Type &, ArrayRef, const void *, const TypeTraits &, bool, const DebugContext &)__CXXMethod { using namespace poplar; -JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, const void * c, const poplar::TypeTraits & d, bool e) {return cl.addConstant(a, jlcxxToPoplar(b), c, d, e);}); -JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, const void * c, const poplar::TypeTraits & d, bool e, std::string f) {return cl.addConstant(a, jlcxxToPoplar(b), c, d, e, f);}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const Type & a, jlcxx::ArrayRef b, const void * c, const TypeTraits & d, bool e) {return cl.addConstant(a, jlcxxToPoplar(b), c, d, e);}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const Type & a, jlcxx::ArrayRef b, const void * c, const TypeTraits & d, bool e, const DebugContext & f) {return cl.addConstant(a, jlcxxToPoplar(b), c, d, e, f);}); } -// poplar::Graph::addConstant(const poplar::Type &, const poplar::Tensor &, ArrayRef, const void *, const poplar::TypeTraits &, bool, const poplar::DebugContext &)__CXXMethod +// poplar::Graph::addConstant(const Type &, const Tensor &, ArrayRef, const void *, const TypeTraits &, bool, const DebugContext &)__CXXMethod { using namespace poplar; -JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, const void * d, const poplar::TypeTraits & e, bool f) {return cl.addConstant(a, b, jlcxxToPoplar(c), d, e, f);}); -JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, jlcxx::ArrayRef c, const void * d, const poplar::TypeTraits & e, bool f, std::string g) {return cl.addConstant(a, b, jlcxxToPoplar(c), d, e, f, g);}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const Type & a, const Tensor & b, jlcxx::ArrayRef c, const void * d, const TypeTraits & e, bool f) {return cl.addConstant(a, b, jlcxxToPoplar(c), d, e, f);}); +JLGraph.method("GraphAddConstant", [](poplar::Graph& cl, const Type & a, const Tensor & b, jlcxx::ArrayRef c, const void * d, const TypeTraits & e, bool f, const DebugContext & g) {return cl.addConstant(a, b, jlcxxToPoplar(c), d, e, f, g);}); } -// poplar::Graph::addConstantHalf(const poplar::Type &, ArrayRef, uint16_t, const poplar::DebugContext &)__CXXMethod +// poplar::Graph::addConstantHalf(const Type &, ArrayRef, uint16_t, const DebugContext &)__CXXMethod { using namespace poplar; -JLGraph.method("GraphAddConstantHalf", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, uint16_t c) {return cl.addConstantHalf(a, jlcxxToPoplar(b), c);}); -JLGraph.method("GraphAddConstantHalf", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, uint16_t c, std::string d) {return cl.addConstantHalf(a, jlcxxToPoplar(b), c, d);}); +JLGraph.method("GraphAddConstantHalf", [](poplar::Graph& cl, const Type & a, jlcxx::ArrayRef b, uint16_t c) {return cl.addConstantHalf(a, jlcxxToPoplar(b), c);}); +JLGraph.method("GraphAddConstantHalf", [](poplar::Graph& cl, const Type & a, jlcxx::ArrayRef b, uint16_t c, const DebugContext & d) {return cl.addConstantHalf(a, jlcxxToPoplar(b), c, d);}); } -// poplar::Graph::addConstantHalf(const poplar::Type &, ArrayRef, const uint16_t *, const poplar::DebugContext &)__CXXMethod +// poplar::Graph::addConstantHalf(const Type &, ArrayRef, const uint16_t *, const DebugContext &)__CXXMethod { using namespace poplar; -JLGraph.method("GraphAddConstantHalf", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, const uint16_t * c) {return cl.addConstantHalf(a, jlcxxToPoplar(b), c);}); -JLGraph.method("GraphAddConstantHalf", [](poplar::Graph& cl, const poplar::Type & a, jlcxx::ArrayRef b, const uint16_t * c, std::string d) {return cl.addConstantHalf(a, jlcxxToPoplar(b), c, d);}); +JLGraph.method("GraphAddConstantHalf", [](poplar::Graph& cl, const Type & a, jlcxx::ArrayRef b, const uint16_t * c) {return cl.addConstantHalf(a, jlcxxToPoplar(b), c);}); +JLGraph.method("GraphAddConstantHalf", [](poplar::Graph& cl, const Type & a, jlcxx::ArrayRef b, const uint16_t * c, const DebugContext & d) {return cl.addConstantHalf(a, jlcxxToPoplar(b), c, d);}); } -// poplar::Graph::clone(const poplar::Type &, const poplar::Tensor &, const poplar::DebugContext &, poplar::TensorCloneMethod)__CXXMethod +// poplar::Graph::clone(const Type &, const Tensor &, const DebugContext &, TensorCloneMethod)__CXXMethod { using namespace poplar; -JLGraph.method("GraphClone", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b) {return cl.clone(a, b);}); -JLGraph.method("GraphClone", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, std::string c) {return cl.clone(a, b, c);}); -JLGraph.method("GraphClone", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, std::string c, poplar::TensorCloneMethod d) {return cl.clone(a, b, c, d);}); +JLGraph.method("GraphClone", [](poplar::Graph& cl, const Type & a, const Tensor & b) {return cl.clone(a, b);}); +JLGraph.method("GraphClone", [](poplar::Graph& cl, const Type & a, const Tensor & b, const DebugContext & c) {return cl.clone(a, b, c);}); +JLGraph.method("GraphClone", [](poplar::Graph& cl, const Type & a, const Tensor & b, const DebugContext & c, TensorCloneMethod d) {return cl.clone(a, b, c, d);}); } -// poplar::Graph::clone(const poplar::Type &, const poplar::Tensor &, const poplar::Tensor &, const poplar::DebugContext &, poplar::TensorCloneMethod)__CXXMethod +// poplar::Graph::clone(const Type &, const Tensor &, const Tensor &, const DebugContext &, TensorCloneMethod)__CXXMethod { using namespace poplar; -JLGraph.method("GraphClone", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, const poplar::Tensor & c) {return cl.clone(a, b, c);}); -JLGraph.method("GraphClone", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, const poplar::Tensor & c, std::string d) {return cl.clone(a, b, c, d);}); -JLGraph.method("GraphClone", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, const poplar::Tensor & c, std::string d, poplar::TensorCloneMethod e) {return cl.clone(a, b, c, d, e);}); +JLGraph.method("GraphClone", [](poplar::Graph& cl, const Type & a, const Tensor & b, const Tensor & c) {return cl.clone(a, b, c);}); +JLGraph.method("GraphClone", [](poplar::Graph& cl, const Type & a, const Tensor & b, const Tensor & c, const DebugContext & d) {return cl.clone(a, b, c, d);}); +JLGraph.method("GraphClone", [](poplar::Graph& cl, const Type & a, const Tensor & b, const Tensor & c, const DebugContext & d, TensorCloneMethod e) {return cl.clone(a, b, c, d, e);}); } -// poplar::Graph::cloneN(const poplar::Type &, const poplar::Tensor &, std::size_t, const poplar::DebugContext &, poplar::TensorCloneMethod, poplar::TensorCloneDuplicationMethod)__CXXMethod +// poplar::Graph::cloneN(const Type &, const Tensor &, std::size_t, const DebugContext &, TensorCloneMethod, TensorCloneDuplicationMethod)__CXXMethod { using namespace poplar; -JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, std::size_t c) {return cl.cloneN(a, b, c);}); -JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, std::size_t c, std::string d) {return cl.cloneN(a, b, c, d);}); -JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, std::size_t c, std::string d, poplar::TensorCloneMethod e) {return cl.cloneN(a, b, c, d, e);}); -JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, std::size_t c, std::string d, poplar::TensorCloneMethod e, poplar::TensorCloneDuplicationMethod f) {return cl.cloneN(a, b, c, d, e, f);}); +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const Type & a, const Tensor & b, std::size_t c) {return cl.cloneN(a, b, c);}); +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const Type & a, const Tensor & b, std::size_t c, const DebugContext & d) {return cl.cloneN(a, b, c, d);}); +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const Type & a, const Tensor & b, std::size_t c, const DebugContext & d, TensorCloneMethod e) {return cl.cloneN(a, b, c, d, e);}); +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const Type & a, const Tensor & b, std::size_t c, const DebugContext & d, TensorCloneMethod e, TensorCloneDuplicationMethod f) {return cl.cloneN(a, b, c, d, e, f);}); } -// poplar::Graph::cloneN(const poplar::Type &, const poplar::Tensor &, const poplar::Tensor &, std::size_t, const poplar::DebugContext &, poplar::TensorCloneMethod, poplar::TensorCloneDuplicationMethod)__CXXMethod +// poplar::Graph::cloneN(const Type &, const Tensor &, const Tensor &, std::size_t, const DebugContext &, TensorCloneMethod, TensorCloneDuplicationMethod)__CXXMethod { using namespace poplar; -JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, const poplar::Tensor & c, std::size_t d) {return cl.cloneN(a, b, c, d);}); -JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, const poplar::Tensor & c, std::size_t d, std::string e) {return cl.cloneN(a, b, c, d, e);}); -JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, const poplar::Tensor & c, std::size_t d, std::string e, poplar::TensorCloneMethod f) {return cl.cloneN(a, b, c, d, e, f);}); -JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Type & a, const poplar::Tensor & b, const poplar::Tensor & c, std::size_t d, std::string e, poplar::TensorCloneMethod f, poplar::TensorCloneDuplicationMethod g) {return cl.cloneN(a, b, c, d, e, f, g);}); +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const Type & a, const Tensor & b, const Tensor & c, std::size_t d) {return cl.cloneN(a, b, c, d);}); +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const Type & a, const Tensor & b, const Tensor & c, std::size_t d, const DebugContext & e) {return cl.cloneN(a, b, c, d, e);}); +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const Type & a, const Tensor & b, const Tensor & c, std::size_t d, const DebugContext & e, TensorCloneMethod f) {return cl.cloneN(a, b, c, d, e, f);}); +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const Type & a, const Tensor & b, const Tensor & c, std::size_t d, const DebugContext & e, TensorCloneMethod f, TensorCloneDuplicationMethod g) {return cl.cloneN(a, b, c, d, e, f, g);}); } -// poplar::Graph::clone(const poplar::Tensor &, const poplar::DebugContext &, poplar::TensorCloneMethod)__CXXMethod +// poplar::Graph::clone(const Tensor &, const DebugContext &, TensorCloneMethod)__CXXMethod { using namespace poplar; -JLGraph.method("GraphClone", [](poplar::Graph& cl, const poplar::Tensor & a) {return cl.clone(a);}); -JLGraph.method("GraphClone", [](poplar::Graph& cl, const poplar::Tensor & a, std::string b) {return cl.clone(a, b);}); -JLGraph.method("GraphClone", [](poplar::Graph& cl, const poplar::Tensor & a, std::string b, poplar::TensorCloneMethod c) {return cl.clone(a, b, c);}); +JLGraph.method("GraphClone", [](poplar::Graph& cl, const Tensor & a) {return cl.clone(a);}); +JLGraph.method("GraphClone", [](poplar::Graph& cl, const Tensor & a, const DebugContext & b) {return cl.clone(a, b);}); +JLGraph.method("GraphClone", [](poplar::Graph& cl, const Tensor & a, const DebugContext & b, TensorCloneMethod c) {return cl.clone(a, b, c);}); } -// poplar::Graph::clone(const poplar::Tensor &, const poplar::Tensor &, const poplar::DebugContext &, poplar::TensorCloneMethod)__CXXMethod +// poplar::Graph::clone(const Tensor &, const Tensor &, const DebugContext &, TensorCloneMethod)__CXXMethod { using namespace poplar; -JLGraph.method("GraphClone", [](poplar::Graph& cl, const poplar::Tensor & a, const poplar::Tensor & b) {return cl.clone(a, b);}); -JLGraph.method("GraphClone", [](poplar::Graph& cl, const poplar::Tensor & a, const poplar::Tensor & b, std::string c) {return cl.clone(a, b, c);}); -JLGraph.method("GraphClone", [](poplar::Graph& cl, const poplar::Tensor & a, const poplar::Tensor & b, std::string c, poplar::TensorCloneMethod d) {return cl.clone(a, b, c, d);}); +JLGraph.method("GraphClone", [](poplar::Graph& cl, const Tensor & a, const Tensor & b) {return cl.clone(a, b);}); +JLGraph.method("GraphClone", [](poplar::Graph& cl, const Tensor & a, const Tensor & b, const DebugContext & c) {return cl.clone(a, b, c);}); +JLGraph.method("GraphClone", [](poplar::Graph& cl, const Tensor & a, const Tensor & b, const DebugContext & c, TensorCloneMethod d) {return cl.clone(a, b, c, d);}); } -// poplar::Graph::cloneN(const poplar::Tensor &, std::size_t, const poplar::DebugContext &, poplar::TensorCloneMethod, poplar::TensorCloneDuplicationMethod)__CXXMethod +// poplar::Graph::cloneN(const Tensor &, std::size_t, const DebugContext &, TensorCloneMethod, TensorCloneDuplicationMethod)__CXXMethod { using namespace poplar; -JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Tensor & a, std::size_t b) {return cl.cloneN(a, b);}); -JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Tensor & a, std::size_t b, std::string c) {return cl.cloneN(a, b, c);}); -JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Tensor & a, std::size_t b, std::string c, poplar::TensorCloneMethod d) {return cl.cloneN(a, b, c, d);}); -JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Tensor & a, std::size_t b, std::string c, poplar::TensorCloneMethod d, poplar::TensorCloneDuplicationMethod e) {return cl.cloneN(a, b, c, d, e);}); +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const Tensor & a, std::size_t b) {return cl.cloneN(a, b);}); +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const Tensor & a, std::size_t b, const DebugContext & c) {return cl.cloneN(a, b, c);}); +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const Tensor & a, std::size_t b, const DebugContext & c, TensorCloneMethod d) {return cl.cloneN(a, b, c, d);}); +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const Tensor & a, std::size_t b, const DebugContext & c, TensorCloneMethod d, TensorCloneDuplicationMethod e) {return cl.cloneN(a, b, c, d, e);}); } -// poplar::Graph::cloneN(const poplar::Tensor &, const poplar::Tensor &, std::size_t, const poplar::DebugContext &, poplar::TensorCloneMethod, poplar::TensorCloneDuplicationMethod)__CXXMethod +// poplar::Graph::cloneN(const Tensor &, const Tensor &, std::size_t, const DebugContext &, TensorCloneMethod, TensorCloneDuplicationMethod)__CXXMethod { using namespace poplar; -JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Tensor & a, const poplar::Tensor & b, std::size_t c) {return cl.cloneN(a, b, c);}); -JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Tensor & a, const poplar::Tensor & b, std::size_t c, std::string d) {return cl.cloneN(a, b, c, d);}); -JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Tensor & a, const poplar::Tensor & b, std::size_t c, std::string d, poplar::TensorCloneMethod e) {return cl.cloneN(a, b, c, d, e);}); -JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const poplar::Tensor & a, const poplar::Tensor & b, std::size_t c, std::string d, poplar::TensorCloneMethod e, poplar::TensorCloneDuplicationMethod f) {return cl.cloneN(a, b, c, d, e, f);}); +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const Tensor & a, const Tensor & b, std::size_t c) {return cl.cloneN(a, b, c);}); +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const Tensor & a, const Tensor & b, std::size_t c, const DebugContext & d) {return cl.cloneN(a, b, c, d);}); +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const Tensor & a, const Tensor & b, std::size_t c, const DebugContext & d, TensorCloneMethod e) {return cl.cloneN(a, b, c, d, e);}); +JLGraph.method("GraphCloneN", [](poplar::Graph& cl, const Tensor & a, const Tensor & b, std::size_t c, const DebugContext & d, TensorCloneMethod e, TensorCloneDuplicationMethod f) {return cl.cloneN(a, b, c, d, e, f);}); } -// poplar::Graph::connect(poplar::FieldRef, const poplar::Tensor &)__CXXMethod +// poplar::Graph::connect(FieldRef, const Tensor &)__CXXMethod { using namespace poplar; -JLGraph.method("GraphConnect", [](poplar::Graph& cl, poplar::FieldRef a, const poplar::Tensor & b) {return cl.connect(a, b);}); +JLGraph.method("GraphConnect", [](poplar::Graph& cl, FieldRef a, const Tensor & b) {return cl.connect(a, b);}); } -// poplar::Graph::connect(poplar::FieldRef, T, typename std::enable_if()>::type *)__FunctionTemplate +// poplar::Graph::connect(FieldRef, T, typename std::enable_if()>::type *)__FunctionTemplate { using namespace poplar; -JLGraph.method("GraphConnect", [](poplar::Graph& cl, poplar::FieldRef a, jlcxx::StrictlyTypedNumber b) {return cl.connect(a, b.value);}); +JLGraph.method("GraphConnect", [](poplar::Graph& cl, FieldRef a, jlcxx::StrictlyTypedNumber b) {return cl.connect(a, b.value);}); }{ using namespace poplar; -JLGraph.method("GraphConnect", [](poplar::Graph& cl, poplar::FieldRef a, jlcxx::StrictlyTypedNumber b) {return cl.connect(a, b.value);}); +JLGraph.method("GraphConnect", [](poplar::Graph& cl, FieldRef a, jlcxx::StrictlyTypedNumber b) {return cl.connect(a, b.value);}); }{ using namespace poplar; -JLGraph.method("GraphConnect", [](poplar::Graph& cl, poplar::FieldRef a, jlcxx::StrictlyTypedNumber b) {return cl.connect(a, b.value);}); +JLGraph.method("GraphConnect", [](poplar::Graph& cl, FieldRef a, jlcxx::StrictlyTypedNumber b) {return cl.connect(a, b.value);}); }{ using namespace poplar; -JLGraph.method("GraphConnect", [](poplar::Graph& cl, poplar::FieldRef a, jlcxx::StrictlyTypedNumber b) {return cl.connect(a, b.value);}); +JLGraph.method("GraphConnect", [](poplar::Graph& cl, FieldRef a, jlcxx::StrictlyTypedNumber b) {return cl.connect(a, b.value);}); }{ using namespace poplar; -JLGraph.method("GraphConnect", [](poplar::Graph& cl, poplar::FieldRef a, jlcxx::StrictlyTypedNumber b) {return cl.connect(a, b.value);}); +JLGraph.method("GraphConnect", [](poplar::Graph& cl, FieldRef a, jlcxx::StrictlyTypedNumber b) {return cl.connect(a, b.value);}); } -// poplar::Graph::connect(poplar::FieldRef, ArrayRef)__CXXMethod +// poplar::Graph::connect(FieldRef, ArrayRef)__CXXMethod { using namespace poplar; -JLGraph.method("GraphConnect", [](poplar::Graph& cl, poplar::FieldRef a, ArrayRef b) {return cl.connect(a, b);}); +JLGraph.method("GraphConnect", [](poplar::Graph& cl, FieldRef a, jlcxx::ArrayRef b) {return cl.connect(a, jlcxxToPoplar(b));}); } -// poplar::Graph::setPerfEstimate(const poplar::VertexRef &, std::uint64_t, std::uint64_t)__CXXMethod +// poplar::Graph::setPerfEstimate(const VertexRef &, std::uint64_t, std::uint64_t)__CXXMethod { using namespace poplar; -JLGraph.method("GraphSetPerfEstimate", [](poplar::Graph& cl, const poplar::VertexRef & a, std::uint64_t b) {return cl.setPerfEstimate(a, b);}); -JLGraph.method("GraphSetPerfEstimate", [](poplar::Graph& cl, const poplar::VertexRef & a, std::uint64_t b, std::uint64_t c) {return cl.setPerfEstimate(a, b, c);}); +JLGraph.method("GraphSetPerfEstimate", [](poplar::Graph& cl, const VertexRef & a, std::uint64_t b) {return cl.setPerfEstimate(a, b);}); +JLGraph.method("GraphSetPerfEstimate", [](poplar::Graph& cl, const VertexRef & a, std::uint64_t b, std::uint64_t c) {return cl.setPerfEstimate(a, b, c);}); } -// poplar::Graph::setPerfEstimate(const poplar::VertexRef &, const poplar::VertexPerfEstimate &)__CXXMethod +// poplar::Graph::setPerfEstimate(const VertexRef &, const VertexPerfEstimate &)__CXXMethod { using namespace poplar; -JLGraph.method("GraphSetPerfEstimate", [](poplar::Graph& cl, const poplar::VertexRef & a, const poplar::VertexPerfEstimate & b) {return cl.setPerfEstimate(a, b);}); +JLGraph.method("GraphSetPerfEstimate", [](poplar::Graph& cl, const VertexRef & a, const VertexPerfEstimate & b) {return cl.setPerfEstimate(a, b);}); } -// poplar::Graph::getPerfEstimate(const poplar::VertexRef &)__CXXMethod +// poplar::Graph::getPerfEstimate(const VertexRef &)__CXXMethod { using namespace poplar; -JLGraph.method("GraphGetPerfEstimate", [](poplar::Graph& cl, const poplar::VertexRef & a) {return cl.getPerfEstimate(a);}); +JLGraph.method("GraphGetPerfEstimate", [](poplar::Graph& cl, const VertexRef & a) {return cl.getPerfEstimate(a);}); } -// poplar::Graph::registerPerfEstimator(std::string, poplar::PerfEstimateFunc)__CXXMethod +// poplar::Graph::registerPerfEstimator(StringRef, PerfEstimateFunc)__CXXMethod { using namespace poplar; -JLGraph.method("GraphRegisterPerfEstimator", [](poplar::Graph& cl, std::string a, poplar::PerfEstimateFunc b) {return cl.registerPerfEstimator(a, b);}); +JLGraph.method("GraphRegisterPerfEstimator", [](poplar::Graph& cl, StringRef a, PerfEstimateFunc b) {return cl.registerPerfEstimator(a, b);}); } // poplar::Graph::getNumVertices()__CXXMethod { using namespace poplar; JLGraph.method("GraphGetNumVertices", [](poplar::Graph& cl) {return cl.getNumVertices();}); } -// poplar::Graph::addComputeSet(const poplar::DebugContext &)__CXXMethod +// poplar::Graph::addComputeSet(const DebugContext &)__CXXMethod { using namespace poplar; JLGraph.method("GraphAddComputeSet", [](poplar::Graph& cl) {return cl.addComputeSet();}); -JLGraph.method("GraphAddComputeSet", [](poplar::Graph& cl, std::string a) {return cl.addComputeSet(a);}); +JLGraph.method("GraphAddComputeSet", [](poplar::Graph& cl, const DebugContext & a) {return cl.addComputeSet(a);}); } -// poplar::Graph::setFieldSize(poplar::FieldRef, std::size_t)__CXXMethod +// poplar::Graph::setFieldSize(FieldRef, std::size_t)__CXXMethod { using namespace poplar; -JLGraph.method("GraphSetFieldSize", [](poplar::Graph& cl, poplar::FieldRef a, std::size_t b) {return cl.setFieldSize(a, b);}); +JLGraph.method("GraphSetFieldSize", [](poplar::Graph& cl, FieldRef a, std::size_t b) {return cl.setFieldSize(a, b);}); } -// poplar::Graph::getFieldSize(poplar::FieldRef)__CXXMethod +// poplar::Graph::getFieldSize(FieldRef)__CXXMethod { using namespace poplar; -JLGraph.method("GraphGetFieldSize", [](poplar::Graph& cl, poplar::FieldRef a) {return cl.getFieldSize(a);}); +JLGraph.method("GraphGetFieldSize", [](poplar::Graph& cl, FieldRef a) {return cl.getFieldSize(a);}); } -// poplar::Graph::getMaxFieldDim(std::string, std::string, unsigned int)__CXXMethod +// poplar::Graph::getMaxFieldDim(StringRef, StringRef, unsigned int)__CXXMethod { using namespace poplar; -JLGraph.method("GraphGetMaxFieldDim", [](poplar::Graph& cl, std::string a, std::string b, unsigned int c) {return cl.getMaxFieldDim(a, b, c);}); +JLGraph.method("GraphGetMaxFieldDim", [](poplar::Graph& cl, StringRef a, StringRef b, unsigned int c) {return cl.getMaxFieldDim(a, b, c);}); } -// poplar::Graph::getMaxVertexFieldValue(std::string, std::string)__CXXMethod +// poplar::Graph::getMaxVertexFieldValue(StringRef, StringRef)__CXXMethod { using namespace poplar; -JLGraph.method("GraphGetMaxVertexFieldValue", [](poplar::Graph& cl, std::string a, std::string b) {return cl.getMaxVertexFieldValue(a, b);}); +JLGraph.method("GraphGetMaxVertexFieldValue", [](poplar::Graph& cl, StringRef a, StringRef b) {return cl.getMaxVertexFieldValue(a, b);}); } -// poplar::Graph::setInitialValueHalf(poplar::FieldRef, uint16_t)__CXXMethod +// poplar::Graph::setInitialValueHalf(FieldRef, uint16_t)__CXXMethod { using namespace poplar; -JLGraph.method("GraphSetInitialValueHalf", [](poplar::Graph& cl, poplar::FieldRef a, uint16_t b) {return cl.setInitialValueHalf(a, b);}); +JLGraph.method("GraphSetInitialValueHalf", [](poplar::Graph& cl, FieldRef a, uint16_t b) {return cl.setInitialValueHalf(a, b);}); } -// poplar::Graph::setInitialValue(poplar::FieldRef, ArrayRef)__FunctionTemplate +// poplar::Graph::setInitialValue(FieldRef, ArrayRef)__FunctionTemplate { using namespace poplar; -JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, poplar::FieldRef a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); +JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, FieldRef a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); }{ using namespace poplar; -JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, poplar::FieldRef a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); +JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, FieldRef a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); }{ using namespace poplar; -JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, poplar::FieldRef a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); +JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, FieldRef a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); }{ using namespace poplar; -JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, poplar::FieldRef a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); +JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, FieldRef a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); }{ using namespace poplar; -JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, poplar::FieldRef a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); +JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, FieldRef a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); } -// poplar::Graph::setInitialValueHalf(poplar::FieldRef, ArrayRef)__CXXMethod +// poplar::Graph::setInitialValueHalf(FieldRef, ArrayRef)__CXXMethod { using namespace poplar; -JLGraph.method("GraphSetInitialValueHalf", [](poplar::Graph& cl, poplar::FieldRef a, jlcxx::ArrayRef b) {return cl.setInitialValueHalf(a, jlcxxToPoplar(b));}); +JLGraph.method("GraphSetInitialValueHalf", [](poplar::Graph& cl, FieldRef a, jlcxx::ArrayRef b) {return cl.setInitialValueHalf(a, jlcxxToPoplar(b));}); } -// poplar::Graph::setInitialValue(const poplar::Tensor &, const std::map &)__CXXMethod +// poplar::Graph::setInitialValue(const Tensor &, const std::map &)__CXXMethod { using namespace poplar; -JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, const poplar::Tensor & a, const std::map & b) {return cl.setInitialValue(a, b);}); +JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, const Tensor & a, const std::map & b) {return cl.setInitialValue(a, b);}); } -// poplar::Graph::setInitialValue(const poplar::Tensor &, ArrayRef)__FunctionTemplate +// poplar::Graph::setInitialValue(const Tensor &, ArrayRef)__FunctionTemplate { using namespace poplar; -JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, const poplar::Tensor & a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); +JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, const Tensor & a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); }{ using namespace poplar; -JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, const poplar::Tensor & a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); +JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, const Tensor & a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); }{ using namespace poplar; -JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, const poplar::Tensor & a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); +JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, const Tensor & a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); }{ using namespace poplar; -JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, const poplar::Tensor & a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); +JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, const Tensor & a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); }{ using namespace poplar; -JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, const poplar::Tensor & a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); +JLGraph.method("GraphSetInitialValue", [](poplar::Graph& cl, const Tensor & a, jlcxx::ArrayRef b) {return cl.setInitialValue(a, jlcxxToPoplar(b));}); } -// poplar::Graph::setInitialValueHalf(const poplar::Tensor &, uint16_t)__CXXMethod +// poplar::Graph::setInitialValueHalf(const Tensor &, uint16_t)__CXXMethod { using namespace poplar; -JLGraph.method("GraphSetInitialValueHalf", [](poplar::Graph& cl, const poplar::Tensor & a, uint16_t b) {return cl.setInitialValueHalf(a, b);}); +JLGraph.method("GraphSetInitialValueHalf", [](poplar::Graph& cl, const Tensor & a, uint16_t b) {return cl.setInitialValueHalf(a, b);}); } -// poplar::Graph::setInitialValueHalf(const poplar::Tensor &, ArrayRef)__CXXMethod +// poplar::Graph::setInitialValueHalf(const Tensor &, ArrayRef)__CXXMethod { using namespace poplar; -JLGraph.method("GraphSetInitialValueHalf", [](poplar::Graph& cl, const poplar::Tensor & a, jlcxx::ArrayRef b) {return cl.setInitialValueHalf(a, jlcxxToPoplar(b));}); +JLGraph.method("GraphSetInitialValueHalf", [](poplar::Graph& cl, const Tensor & a, jlcxx::ArrayRef b) {return cl.setInitialValueHalf(a, jlcxxToPoplar(b));}); } -// poplar::Graph::createHostWrite(std::string, const poplar::Tensor &, bool)__CXXMethod +// poplar::Graph::createHostWrite(StringRef, const Tensor &, bool)__CXXMethod { using namespace poplar; -JLGraph.method("GraphCreateHostWrite", [](poplar::Graph& cl, std::string a, const poplar::Tensor & b) {return cl.createHostWrite(a, b);}); -JLGraph.method("GraphCreateHostWrite", [](poplar::Graph& cl, std::string a, const poplar::Tensor & b, bool c) {return cl.createHostWrite(a, b, c);}); +JLGraph.method("GraphCreateHostWrite", [](poplar::Graph& cl, StringRef a, const Tensor & b) {return cl.createHostWrite(a, b);}); +JLGraph.method("GraphCreateHostWrite", [](poplar::Graph& cl, StringRef a, const Tensor & b, bool c) {return cl.createHostWrite(a, b, c);}); } -// poplar::Graph::createHostRead(std::string, const poplar::Tensor &, bool)__CXXMethod +// poplar::Graph::createHostRead(StringRef, const Tensor &, bool)__CXXMethod { using namespace poplar; -JLGraph.method("GraphCreateHostRead", [](poplar::Graph& cl, std::string a, const poplar::Tensor & b) {return cl.createHostRead(a, b);}); -JLGraph.method("GraphCreateHostRead", [](poplar::Graph& cl, std::string a, const poplar::Tensor & b, bool c) {return cl.createHostRead(a, b, c);}); +JLGraph.method("GraphCreateHostRead", [](poplar::Graph& cl, StringRef a, const Tensor & b) {return cl.createHostRead(a, b);}); +JLGraph.method("GraphCreateHostRead", [](poplar::Graph& cl, StringRef a, const Tensor & b, bool c) {return cl.createHostRead(a, b, c);}); } -// poplar::Graph::addHostToDeviceFIFO(std::string, const poplar::Type &, std::size_t, poplar::ReplicatedStreamMode, const poplar::OptionFlags &)__CXXMethod +// poplar::Graph::addHostToDeviceFIFO(StringRef, const Type &, std::size_t, ReplicatedStreamMode, const OptionFlags &)__CXXMethod { using namespace poplar; -JLGraph.method("GraphAddHostToDeviceFIFO", [](poplar::Graph& cl, std::string a, const poplar::Type & b, std::size_t c) {return cl.addHostToDeviceFIFO(a, b, c);}); -JLGraph.method("GraphAddHostToDeviceFIFO", [](poplar::Graph& cl, std::string a, const poplar::Type & b, std::size_t c, poplar::ReplicatedStreamMode d) {return cl.addHostToDeviceFIFO(a, b, c, d);}); -JLGraph.method("GraphAddHostToDeviceFIFO", [](poplar::Graph& cl, std::string a, const poplar::Type & b, std::size_t c, poplar::ReplicatedStreamMode d, const poplar::OptionFlags & e) {return cl.addHostToDeviceFIFO(a, b, c, d, e);}); +JLGraph.method("GraphAddHostToDeviceFIFO", [](poplar::Graph& cl, StringRef a, const Type & b, std::size_t c) {return cl.addHostToDeviceFIFO(a, b, c);}); +JLGraph.method("GraphAddHostToDeviceFIFO", [](poplar::Graph& cl, StringRef a, const Type & b, std::size_t c, ReplicatedStreamMode d) {return cl.addHostToDeviceFIFO(a, b, c, d);}); +JLGraph.method("GraphAddHostToDeviceFIFO", [](poplar::Graph& cl, StringRef a, const Type & b, std::size_t c, ReplicatedStreamMode d, const OptionFlags & e) {return cl.addHostToDeviceFIFO(a, b, c, d, e);}); } -// poplar::Graph::addDeviceToHostFIFO(std::string, const poplar::Type &, std::size_t, const poplar::OptionFlags &)__CXXMethod +// poplar::Graph::addDeviceToHostFIFO(StringRef, const Type &, std::size_t, const OptionFlags &)__CXXMethod { using namespace poplar; -JLGraph.method("GraphAddDeviceToHostFIFO", [](poplar::Graph& cl, std::string a, const poplar::Type & b, std::size_t c) {return cl.addDeviceToHostFIFO(a, b, c);}); -JLGraph.method("GraphAddDeviceToHostFIFO", [](poplar::Graph& cl, std::string a, const poplar::Type & b, std::size_t c, const poplar::OptionFlags & d) {return cl.addDeviceToHostFIFO(a, b, c, d);}); +JLGraph.method("GraphAddDeviceToHostFIFO", [](poplar::Graph& cl, StringRef a, const Type & b, std::size_t c) {return cl.addDeviceToHostFIFO(a, b, c);}); +JLGraph.method("GraphAddDeviceToHostFIFO", [](poplar::Graph& cl, StringRef a, const Type & b, std::size_t c, const OptionFlags & d) {return cl.addDeviceToHostFIFO(a, b, c, d);}); } -// poplar::Graph::addRemoteBuffer(std::string, const poplar::Type &, std::size_t, std::size_t, bool, bool)__CXXMethod +// poplar::Graph::addRemoteBuffer(StringRef, const Type &, std::size_t, std::size_t, bool, bool)__CXXMethod { using namespace poplar; -JLGraph.method("GraphAddRemoteBuffer", [](poplar::Graph& cl, std::string a, const poplar::Type & b, std::size_t c) {return cl.addRemoteBuffer(a, b, c);}); -JLGraph.method("GraphAddRemoteBuffer", [](poplar::Graph& cl, std::string a, const poplar::Type & b, std::size_t c, std::size_t d) {return cl.addRemoteBuffer(a, b, c, d);}); -JLGraph.method("GraphAddRemoteBuffer", [](poplar::Graph& cl, std::string a, const poplar::Type & b, std::size_t c, std::size_t d, bool e) {return cl.addRemoteBuffer(a, b, c, d, e);}); -JLGraph.method("GraphAddRemoteBuffer", [](poplar::Graph& cl, std::string a, const poplar::Type & b, std::size_t c, std::size_t d, bool e, bool f) {return cl.addRemoteBuffer(a, b, c, d, e, f);}); +JLGraph.method("GraphAddRemoteBuffer", [](poplar::Graph& cl, StringRef a, const Type & b, std::size_t c) {return cl.addRemoteBuffer(a, b, c);}); +JLGraph.method("GraphAddRemoteBuffer", [](poplar::Graph& cl, StringRef a, const Type & b, std::size_t c, std::size_t d) {return cl.addRemoteBuffer(a, b, c, d);}); +JLGraph.method("GraphAddRemoteBuffer", [](poplar::Graph& cl, StringRef a, const Type & b, std::size_t c, std::size_t d, bool e) {return cl.addRemoteBuffer(a, b, c, d, e);}); +JLGraph.method("GraphAddRemoteBuffer", [](poplar::Graph& cl, StringRef a, const Type & b, std::size_t c, std::size_t d, bool e, bool f) {return cl.addRemoteBuffer(a, b, c, d, e, f);}); } -// poplar::Graph::setTileMapping(poplar::VertexRef, unsigned int)__CXXMethod +// poplar::Graph::setTileMapping(VertexRef, unsigned int)__CXXMethod { using namespace poplar; -JLGraph.method("GraphSetTileMapping", [](poplar::Graph& cl, poplar::VertexRef a, unsigned int b) {return cl.setTileMapping(a, b);}); +JLGraph.method("GraphSetTileMapping", [](poplar::Graph& cl, VertexRef a, unsigned int b) {return cl.setTileMapping(a, b);}); } -// poplar::Graph::setTileMapping(const poplar::Tensor &, unsigned int)__CXXMethod +// poplar::Graph::setTileMapping(const Tensor &, unsigned int)__CXXMethod { using namespace poplar; -JLGraph.method("GraphSetTileMapping", [](poplar::Graph& cl, const poplar::Tensor & a, unsigned int b) {return cl.setTileMapping(a, b);}); +JLGraph.method("GraphSetTileMapping", [](poplar::Graph& cl, const Tensor & a, unsigned int b) {return cl.setTileMapping(a, b);}); } -// poplar::Graph::getTileMapping(const poplar::Tensor &, bool, bool)__CXXMethod +// poplar::Graph::getTileMapping(const Tensor &, bool, bool)__CXXMethod { using namespace poplar; -JLGraph.method("GraphGetTileMapping", [](poplar::Graph& cl, const poplar::Tensor & a) {return cl.getTileMapping(a);}); -JLGraph.method("GraphGetTileMapping", [](poplar::Graph& cl, const poplar::Tensor & a, bool b) {return cl.getTileMapping(a, b);}); -JLGraph.method("GraphGetTileMapping", [](poplar::Graph& cl, const poplar::Tensor & a, bool b, bool c) {return cl.getTileMapping(a, b, c);}); +JLGraph.method("GraphGetTileMapping", [](poplar::Graph& cl, const Tensor & a) {return cl.getTileMapping(a);}); +JLGraph.method("GraphGetTileMapping", [](poplar::Graph& cl, const Tensor & a, bool b) {return cl.getTileMapping(a, b);}); +JLGraph.method("GraphGetTileMapping", [](poplar::Graph& cl, const Tensor & a, bool b, bool c) {return cl.getTileMapping(a, b, c);}); } -// poplar::Graph::getTileMapping(const poplar::Tensor &, bool *, bool)__CXXMethod +// poplar::Graph::getTileMapping(const Tensor &, bool *, bool)__CXXMethod { using namespace poplar; -JLGraph.method("GraphGetTileMapping", [](poplar::Graph& cl, const poplar::Tensor & a, bool * b) {return cl.getTileMapping(a, b);}); -JLGraph.method("GraphGetTileMapping", [](poplar::Graph& cl, const poplar::Tensor & a, bool * b, bool c) {return cl.getTileMapping(a, b, c);}); +JLGraph.method("GraphGetTileMapping", [](poplar::Graph& cl, const Tensor & a, bool * b) {return cl.getTileMapping(a, b);}); +JLGraph.method("GraphGetTileMapping", [](poplar::Graph& cl, const Tensor & a, bool * b, bool c) {return cl.getTileMapping(a, b, c);}); } -// poplar::Graph::getVariableTileMapping(const poplar::Tensor &)__CXXMethod +// poplar::Graph::getVariableTileMapping(const Tensor &)__CXXMethod { using namespace poplar; -JLGraph.method("GraphGetVariableTileMapping", [](poplar::Graph& cl, const poplar::Tensor & a) {return cl.getVariableTileMapping(a);}); +JLGraph.method("GraphGetVariableTileMapping", [](poplar::Graph& cl, const Tensor & a) {return cl.getVariableTileMapping(a);}); } -// poplar::Graph::setTileMapping(const poplar::Tensor &, const poplar::Graph::TileToTensorMapping &)__CXXMethod +// poplar::Graph::setTileMapping(const Tensor &, const TileToTensorMapping &)__CXXMethod { using namespace poplar; -JLGraph.method("GraphSetTileMapping", [](poplar::Graph& cl, const poplar::Tensor & a, const poplar::Graph::TileToTensorMapping & b) {return cl.setTileMapping(a, b);}); +JLGraph.method("GraphSetTileMapping", [](poplar::Graph& cl, const Tensor & a, const TileToTensorMapping & b) {return cl.setTileMapping(a, b);}); } -// poplar::Graph::getVariable(poplar::VariableRef)__CXXMethod +// poplar::Graph::getVariable(VariableRef)__CXXMethod { using namespace poplar; -JLGraph.method("GraphGetVariable", [](poplar::Graph& cl, poplar::VariableRef a) {return cl.getVariable(a);}); +JLGraph.method("GraphGetVariable", [](poplar::Graph& cl, VariableRef a) {return cl.getVariable(a);}); } -// poplar::Graph::isConstant(poplar::VariableRef)__CXXMethod +// poplar::Graph::isConstant(VariableRef)__CXXMethod { using namespace poplar; -JLGraph.method("GraphIsConstant", [](poplar::Graph& cl, poplar::VariableRef a) {return cl.isConstant(a);}); +JLGraph.method("GraphIsConstant", [](poplar::Graph& cl, VariableRef a) {return cl.isConstant(a);}); } -// poplar::Graph::getSortedContiguousRegions(const poplar::Tensor &, ArrayRef, bool, std::vector *)__CXXMethod +// poplar::Graph::getSortedContiguousRegions(const Tensor &, ArrayRef, bool, std::vector *)__CXXMethod { using namespace poplar; -JLGraph.method("GraphGetSortedContiguousRegions", [](poplar::Graph& cl, const poplar::Tensor & a, ArrayRef b) {return cl.getSortedContiguousRegions(a, b);}); -JLGraph.method("GraphGetSortedContiguousRegions", [](poplar::Graph& cl, const poplar::Tensor & a, ArrayRef b, bool c) {return cl.getSortedContiguousRegions(a, b, c);}); -JLGraph.method("GraphGetSortedContiguousRegions", [](poplar::Graph& cl, const poplar::Tensor & a, ArrayRef b, bool c, std::vector * d) {return cl.getSortedContiguousRegions(a, b, c, d);}); +JLGraph.method("GraphGetSortedContiguousRegions", [](poplar::Graph& cl, const Tensor & a, jlcxx::ArrayRef b) {return cl.getSortedContiguousRegions(a, jlcxxToPoplar(b));}); +JLGraph.method("GraphGetSortedContiguousRegions", [](poplar::Graph& cl, const Tensor & a, jlcxx::ArrayRef b, bool c) {return cl.getSortedContiguousRegions(a, jlcxxToPoplar(b), c);}); +JLGraph.method("GraphGetSortedContiguousRegions", [](poplar::Graph& cl, const Tensor & a, jlcxx::ArrayRef b, bool c, std::vector * d) {return cl.getSortedContiguousRegions(a, jlcxxToPoplar(b), c, d);}); } -// poplar::Graph::reorderToSimplify(poplar::Tensor *, ArrayRef, bool)__CXXMethod +// poplar::Graph::reorderToSimplify(Tensor *, ArrayRef, bool)__CXXMethod { using namespace poplar; -JLGraph.method("GraphReorderToSimplify", [](poplar::Graph& cl, poplar::Tensor * a, ArrayRef b) {return cl.reorderToSimplify(a, b);}); -JLGraph.method("GraphReorderToSimplify", [](poplar::Graph& cl, poplar::Tensor * a, ArrayRef b, bool c) {return cl.reorderToSimplify(a, b, c);}); +JLGraph.method("GraphReorderToSimplify", [](poplar::Graph& cl, Tensor * a, jlcxx::ArrayRef b) {return cl.reorderToSimplify(a, jlcxxToPoplar(b));}); +JLGraph.method("GraphReorderToSimplify", [](poplar::Graph& cl, Tensor * a, jlcxx::ArrayRef b, bool c) {return cl.reorderToSimplify(a, jlcxxToPoplar(b), c);}); } -// poplar::Graph::getSimplifyingRearranger(const poplar::Tensor &)__CXXMethod +// poplar::Graph::getSimplifyingRearranger(const Tensor &)__CXXMethod { using namespace poplar; -JLGraph.method("GraphGetSimplifyingRearranger", [](poplar::Graph& cl, const poplar::Tensor & a) {return cl.getSimplifyingRearranger(a);}); +JLGraph.method("GraphGetSimplifyingRearranger", [](poplar::Graph& cl, const Tensor & a) {return cl.getSimplifyingRearranger(a);}); } -// poplar::Graph::findUnbroadcastTensor(const poplar::Tensor &)__CXXMethod +// poplar::Graph::findUnbroadcastTensor(const Tensor &)__CXXMethod { using namespace poplar; -JLGraph.method("GraphFindUnbroadcastTensor", [](poplar::Graph& cl, const poplar::Tensor & a) {return cl.findUnbroadcastTensor(a);}); +JLGraph.method("GraphFindUnbroadcastTensor", [](poplar::Graph& cl, const Tensor & a) {return cl.findUnbroadcastTensor(a);}); } // poplar::Graph::createVirtualGraph(unsigned int)__CXXMethod { using namespace poplar; @@ -2354,22 +2361,22 @@ JLGraph.method("GraphGetTopLevelGraph", [](poplar::Graph& cl) {return cl.getTopL { using namespace poplar; JLGraph.method("GraphGetReplicationFactor", [](poplar::Graph& cl) {return cl.getReplicationFactor();}); } -// poplar::Graph::addReplicationIndexConstant(const poplar::DebugContext &)__CXXMethod +// poplar::Graph::addReplicationIndexConstant(const DebugContext &)__CXXMethod { using namespace poplar; JLGraph.method("GraphAddReplicationIndexConstant", [](poplar::Graph& cl) {return cl.addReplicationIndexConstant();}); -JLGraph.method("GraphAddReplicationIndexConstant", [](poplar::Graph& cl, std::string a) {return cl.addReplicationIndexConstant(a);}); +JLGraph.method("GraphAddReplicationIndexConstant", [](poplar::Graph& cl, const DebugContext & a) {return cl.addReplicationIndexConstant(a);}); } // poplar::Graph::addFunction(const program::Program &)__CXXMethod { using namespace poplar; JLGraph.method("GraphAddFunction", [](poplar::Graph& cl, const program::Program & a) {return cl.addFunction(a);}); } -// poplar::Graph::addFunctionBuffer(const poplar::Function &, poplar::FunctionBufferMappingType)__CXXMethod +// poplar::Graph::addFunctionBuffer(const Function &, FunctionBufferMappingType)__CXXMethod { using namespace poplar; -JLGraph.method("GraphAddFunctionBuffer", [](poplar::Graph& cl, const poplar::Function & a, poplar::FunctionBufferMappingType b) {return cl.addFunctionBuffer(a, b);}); +JLGraph.method("GraphAddFunctionBuffer", [](poplar::Graph& cl, const Function & a, FunctionBufferMappingType b) {return cl.addFunctionBuffer(a, b);}); } -// poplar::Graph::addHostFunction(std::string, ArrayRef, ArrayRef)__CXXMethod +// poplar::Graph::addHostFunction(StringRef, ArrayRef, ArrayRef)__CXXMethod { using namespace poplar; -JLGraph.method("GraphAddHostFunction", [](poplar::Graph& cl, std::string a, ArrayRef b, ArrayRef c) {return cl.addHostFunction(a, b, c);}); +JLGraph.method("GraphAddHostFunction", [](poplar::Graph& cl, StringRef a, jlcxx::ArrayRef b, jlcxx::ArrayRef c) {return cl.addHostFunction(a, jlcxxToPoplar(b), jlcxxToPoplar(c));}); } // poplar::Graph::convertTileToTopLevelGraphTile(unsigned int)__CXXMethod { using namespace poplar; @@ -2391,17 +2398,17 @@ JLGraph.method("GraphConvertPhysicalTileToVirtualTile", [](poplar::Graph& cl, un { using namespace poplar; JLGraph.method("GraphConvertPhysicalTileToVirtualTile", [](poplar::Graph& cl, unsigned int a, unsigned int b) {return cl.convertPhysicalTileToVirtualTile(a, b);}); } -// poplar::Graph::hasCodelet(std::string)__CXXMethod +// poplar::Graph::hasCodelet(StringRef)__CXXMethod { using namespace poplar; -JLGraph.method("GraphHasCodelet", [](poplar::Graph& cl, std::string a) {return cl.hasCodelet(a);}); +JLGraph.method("GraphHasCodelet", [](poplar::Graph& cl, StringRef a) {return cl.hasCodelet(a);}); } -// poplar::RuntimeOptions::RuntimeOptions(const poplar::OptionFlags &)__CXXConstructor +// poplar::RuntimeOptions::RuntimeOptions(const OptionFlags &)__CXXConstructor { using namespace poplar; -JLRuntimeOptions.constructor(); +JLRuntimeOptions.constructor(); } -// poplar::RuntimeOptions::RuntimeOptions(const poplar::RuntimeOptions &)__CXXConstructor +// poplar::RuntimeOptions::RuntimeOptions(const RuntimeOptions &)__CXXConstructor { using namespace poplar; -JLRuntimeOptions.constructor(); +JLRuntimeOptions.constructor(); } // poplar::StreamCallbackBase::Result::Success__EnumConstantDecl mod.set_const("StreamCallbackBaseResultStreamCallbackBaseSuccess", poplar::StreamCallbackBase::Result::Success); @@ -2447,35 +2454,35 @@ JLLegacyStreamCallback.method("LegacyStreamCallbackInvalidatePrefetched", [](pop { using namespace poplar; JLLegacyStreamCallback.method("LegacyStreamCallbackComplete", [](poplar::LegacyStreamCallback& cl) {return cl.complete();}); } -// poplar::Engine::Engine(const poplar::Graph &, ArrayRef, const poplar::OptionFlags &, poplar::Engine::ProgressFunc, const poplar::DebugContext &)__CXXConstructor +// poplar::Engine::Engine(const Graph &, ArrayRef, const OptionFlags &, ProgressFunc, const DebugContext &)__CXXConstructor { using namespace poplar; -JLEngine.constructor>(); -JLEngine.constructor, const poplar::OptionFlags &>(); -JLEngine.constructor, const poplar::OptionFlags &, poplar::Engine::ProgressFunc>(); -JLEngine.constructor, const poplar::OptionFlags &, poplar::Engine::ProgressFunc, std::string>(); +JLEngine.constructor>(); +JLEngine.constructor, const OptionFlags &>(); +JLEngine.constructor, const OptionFlags &, ProgressFunc>(); +JLEngine.constructor, const OptionFlags &, ProgressFunc, const DebugContext &>(); } -// poplar::Engine::Engine(const poplar::Graph &, program::Program, const poplar::OptionFlags &, poplar::Engine::ProgressFunc, const poplar::DebugContext &)__CXXConstructor +// poplar::Engine::Engine(const Graph &, program::Program, const OptionFlags &, ProgressFunc, const DebugContext &)__CXXConstructor { using namespace poplar; -JLEngine.constructor(); -JLEngine.constructor(); -JLEngine.constructor(); -JLEngine.constructor(); +JLEngine.constructor(); +JLEngine.constructor(); +JLEngine.constructor(); +JLEngine.constructor(); } -// poplar::Engine::prepare(const poplar::Device &)__CXXMethod +// poplar::Engine::prepare(const Device &)__CXXMethod { using namespace poplar; -JLEngine.method("EnginePrepare", [](poplar::Engine& cl, const poplar::Device & a) {return cl.prepare(a);}); +JLEngine.method("EnginePrepare", [](poplar::Engine& cl, const Device & a) {return cl.prepare(a);}); } -// poplar::Engine::prepare(const poplar::Device &, const poplar::RuntimeOptions &)__CXXMethod +// poplar::Engine::prepare(const Device &, const RuntimeOptions &)__CXXMethod { using namespace poplar; -JLEngine.method("EnginePrepare", [](poplar::Engine& cl, const poplar::Device & a, const poplar::RuntimeOptions & b) {return cl.prepare(a, b);}); +JLEngine.method("EnginePrepare", [](poplar::Engine& cl, const Device & a, const RuntimeOptions & b) {return cl.prepare(a, b);}); } // poplar::Engine::deploy()__CXXMethod { using namespace poplar; JLEngine.method("EngineDeploy", [](poplar::Engine& cl) {return cl.deploy();}); } -// poplar::Engine::load(const poplar::Device &)__CXXMethod +// poplar::Engine::load(const Device &)__CXXMethod { using namespace poplar; -JLEngine.method("EngineLoad", [](poplar::Engine& cl, const poplar::Device & a) {return cl.load(a);}); +JLEngine.method("EngineLoad", [](poplar::Engine& cl, const Device & a) {return cl.load(a);}); } // poplar::Engine::run(unsigned int, const std::string &)__CXXMethod { using namespace poplar; @@ -2487,22 +2494,22 @@ JLEngine.method("EngineRun", [](poplar::Engine& cl, unsigned int a, const std::s { using namespace poplar; JLEngine.method("EngineStop", [](poplar::Engine& cl) {return cl.stop();}); } -// poplar::Engine::run(unsigned int, const std::string &, const poplar::RuntimeOptions &)__CXXMethod +// poplar::Engine::run(unsigned int, const std::string &, const RuntimeOptions &)__CXXMethod { using namespace poplar; -JLEngine.method("EngineRun", [](poplar::Engine& cl, unsigned int a, const std::string & b, const poplar::RuntimeOptions & c) {return cl.run(a, b, c);}); +JLEngine.method("EngineRun", [](poplar::Engine& cl, unsigned int a, const std::string & b, const RuntimeOptions & c) {return cl.run(a, b, c);}); } -// poplar::Engine::loadAndRun(const poplar::Device &, unsigned int)__CXXMethod +// poplar::Engine::loadAndRun(const Device &, unsigned int)__CXXMethod { using namespace poplar; -JLEngine.method("EngineLoadAndRun", [](poplar::Engine& cl, const poplar::Device & a) {return cl.loadAndRun(a);}); -JLEngine.method("EngineLoadAndRun", [](poplar::Engine& cl, const poplar::Device & a, unsigned int b) {return cl.loadAndRun(a, b);}); +JLEngine.method("EngineLoadAndRun", [](poplar::Engine& cl, const Device & a) {return cl.loadAndRun(a);}); +JLEngine.method("EngineLoadAndRun", [](poplar::Engine& cl, const Device & a, unsigned int b) {return cl.loadAndRun(a, b);}); } // poplar::Engine::getTimeStamp()__CXXMethod { using namespace poplar; JLEngine.method("EngineGetTimeStamp", [](poplar::Engine& cl) {return cl.getTimeStamp();}); } -// poplar::Engine::reportTiming(const poplar::Engine::TimerTimePoint &, const poplar::Engine::TimerTimePoint &)__CXXMethod +// poplar::Engine::reportTiming(const TimerTimePoint &, const TimerTimePoint &)__CXXMethod { using namespace poplar; -JLEngine.method("EngineReportTiming", [](poplar::Engine& cl, const poplar::Engine::TimerTimePoint & a, const poplar::Engine::TimerTimePoint & b) {return cl.reportTiming(a, b);}); +JLEngine.method("EngineReportTiming", [](poplar::Engine& cl, const TimerTimePoint & a, const TimerTimePoint & b) {return cl.reportTiming(a, b);}); } // poplar::Engine::resetExecutionProfile()__CXXMethod { using namespace poplar; @@ -2516,75 +2523,92 @@ JLEngine.method("EngineDisableExecutionProfiling", [](poplar::Engine& cl) {retur { using namespace poplar; JLEngine.method("EngineEnableExecutionProfiling", [](poplar::Engine& cl) {return cl.enableExecutionProfiling();}); } -// poplar::Engine::readTensor(std::string, void *, void *)__CXXMethod +// poplar::Engine::readTensor(StringRef, void *, void *)__CXXMethod { using namespace poplar; -JLEngine.method("EngineReadTensor", [](poplar::Engine& cl, std::string a, void * b, void * c) {return cl.readTensor(a, b, c);}); +JLEngine.method("EngineReadTensor", [](poplar::Engine& cl, StringRef a, void * b, void * c) {return cl.readTensor(a, b, c);}); } -// poplar::Engine::readTensor(std::string, gccs::ArrayRef)__FunctionTemplate +// poplar::Engine::readTensor(StringRef, gccs::ArrayRef)__FunctionTemplate { using namespace poplar; -JLEngine.method("EngineReadTensor", [](poplar::Engine& cl, std::string a, gccs::ArrayRef b) {return cl.readTensor(a, b);}); +JLEngine.method("EngineReadTensor", [](poplar::Engine& cl, StringRef a, gccs::ArrayRef b) {return cl.readTensor(a, b);}); }{ using namespace poplar; -JLEngine.method("EngineReadTensor", [](poplar::Engine& cl, std::string a, gccs::ArrayRef b) {return cl.readTensor(a, b);}); +JLEngine.method("EngineReadTensor", [](poplar::Engine& cl, StringRef a, gccs::ArrayRef b) {return cl.readTensor(a, b);}); }{ using namespace poplar; -JLEngine.method("EngineReadTensor", [](poplar::Engine& cl, std::string a, gccs::ArrayRef b) {return cl.readTensor(a, b);}); +JLEngine.method("EngineReadTensor", [](poplar::Engine& cl, StringRef a, gccs::ArrayRef b) {return cl.readTensor(a, b);}); }{ using namespace poplar; -JLEngine.method("EngineReadTensor", [](poplar::Engine& cl, std::string a, gccs::ArrayRef b) {return cl.readTensor(a, b);}); +JLEngine.method("EngineReadTensor", [](poplar::Engine& cl, StringRef a, gccs::ArrayRef b) {return cl.readTensor(a, b);}); } -// poplar::Engine::writeTensor(std::string, const void *, const void *)__CXXMethod +// poplar::Engine::writeTensor(StringRef, const void *, const void *)__CXXMethod { using namespace poplar; -JLEngine.method("EngineWriteTensor", [](poplar::Engine& cl, std::string a, const void * b, const void * c) {return cl.writeTensor(a, b, c);}); +JLEngine.method("EngineWriteTensor", [](poplar::Engine& cl, StringRef a, const void * b, const void * c) {return cl.writeTensor(a, b, c);}); } -// poplar::Engine::writeTensor(std::string, ArrayRef)__FunctionTemplate +// poplar::Engine::writeTensor(StringRef, ArrayRef)__FunctionTemplate { using namespace poplar; -JLEngine.method("EngineWriteTensor", [](poplar::Engine& cl, std::string a, jlcxx::ArrayRef b) {return cl.writeTensor(a, jlcxxToPoplar(b));}); +JLEngine.method("EngineWriteTensor", [](poplar::Engine& cl, StringRef a, jlcxx::ArrayRef b) {return cl.writeTensor(a, jlcxxToPoplar(b));}); }{ using namespace poplar; -JLEngine.method("EngineWriteTensor", [](poplar::Engine& cl, std::string a, jlcxx::ArrayRef b) {return cl.writeTensor(a, jlcxxToPoplar(b));}); +JLEngine.method("EngineWriteTensor", [](poplar::Engine& cl, StringRef a, jlcxx::ArrayRef b) {return cl.writeTensor(a, jlcxxToPoplar(b));}); }{ using namespace poplar; -JLEngine.method("EngineWriteTensor", [](poplar::Engine& cl, std::string a, jlcxx::ArrayRef b) {return cl.writeTensor(a, jlcxxToPoplar(b));}); +JLEngine.method("EngineWriteTensor", [](poplar::Engine& cl, StringRef a, jlcxx::ArrayRef b) {return cl.writeTensor(a, jlcxxToPoplar(b));}); }{ using namespace poplar; -JLEngine.method("EngineWriteTensor", [](poplar::Engine& cl, std::string a, jlcxx::ArrayRef b) {return cl.writeTensor(a, jlcxxToPoplar(b));}); +JLEngine.method("EngineWriteTensor", [](poplar::Engine& cl, StringRef a, jlcxx::ArrayRef b) {return cl.writeTensor(a, jlcxxToPoplar(b));}); } -// poplar::Engine::connectStream(std::string, void *, void *)__CXXMethod +// poplar::Engine::connectStream(StringRef, void *, void *)__CXXMethod { using namespace poplar; -JLEngine.method("EngineConnectStream", [](poplar::Engine& cl, std::string a, void * b, void * c) {return cl.connectStream(a, b, c);}); +JLEngine.method("EngineConnectStream", [](poplar::Engine& cl, StringRef a, void * b, void * c) {return cl.connectStream(a, b, c);}); } -// poplar::Engine::connectStream(std::string, const gccs::ArrayRef &)__FunctionTemplate +// poplar::Engine::connectStream(StringRef, const gccs::ArrayRef &)__FunctionTemplate { using namespace poplar; -JLEngine.method("EngineConnectStream", [](poplar::Engine& cl, std::string a, const gccs::ArrayRef & b) {return cl.connectStream(a, b);}); +JLEngine.method("EngineConnectStream", [](poplar::Engine& cl, StringRef a, const gccs::ArrayRef & b) {return cl.connectStream(a, b);}); }{ using namespace poplar; -JLEngine.method("EngineConnectStream", [](poplar::Engine& cl, std::string a, const gccs::ArrayRef & b) {return cl.connectStream(a, b);}); +JLEngine.method("EngineConnectStream", [](poplar::Engine& cl, StringRef a, const gccs::ArrayRef & b) {return cl.connectStream(a, b);}); }{ using namespace poplar; -JLEngine.method("EngineConnectStream", [](poplar::Engine& cl, std::string a, const gccs::ArrayRef & b) {return cl.connectStream(a, b);}); +JLEngine.method("EngineConnectStream", [](poplar::Engine& cl, StringRef a, const gccs::ArrayRef & b) {return cl.connectStream(a, b);}); }{ using namespace poplar; -JLEngine.method("EngineConnectStream", [](poplar::Engine& cl, std::string a, const gccs::ArrayRef & b) {return cl.connectStream(a, b);}); +JLEngine.method("EngineConnectStream", [](poplar::Engine& cl, StringRef a, const gccs::ArrayRef & b) {return cl.connectStream(a, b);}); } -// poplar::Engine::connectStream(std::string, void *)__CXXMethod +// poplar::Engine::connectStream(StringRef, void *)__CXXMethod { using namespace poplar; -JLEngine.method("EngineConnectStream", [](poplar::Engine& cl, std::string a, void * b) {return cl.connectStream(a, b);}); +JLEngine.method("EngineConnectStream", [](poplar::Engine& cl, StringRef a, void * b) {return cl.connectStream(a, b);}); } -// poplar::Engine::copyFromRemoteBuffer(std::string, void *, uint64_t, unsigned int)__CXXMethod +// poplar::Engine::copyFromRemoteBuffer(StringRef, void *, uint64_t, unsigned int)__CXXMethod { using namespace poplar; -JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, std::string a, void * b, uint64_t c) {return cl.copyFromRemoteBuffer(a, b, c);}); -JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, std::string a, void * b, uint64_t c, unsigned int d) {return cl.copyFromRemoteBuffer(a, b, c, d);}); +JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, StringRef a, void * b, uint64_t c) {return cl.copyFromRemoteBuffer(a, b, c);}); +JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, StringRef a, void * b, uint64_t c, unsigned int d) {return cl.copyFromRemoteBuffer(a, b, c, d);}); } -// poplar::Engine::copyFromRemoteBuffer(std::string, gccs::ArrayRef, uint64_t, unsigned int)__FunctionTemplate +// poplar::Engine::copyFromRemoteBuffer(StringRef, gccs::ArrayRef, uint64_t, unsigned int)__FunctionTemplate { using namespace poplar; -JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, std::string a, gccs::ArrayRef b, uint64_t c) {return cl.copyFromRemoteBuffer(a, b, c);}); -JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, std::string a, gccs::ArrayRef b, uint64_t c, unsigned int d) {return cl.copyFromRemoteBuffer(a, b, c, d);}); +JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, StringRef a, gccs::ArrayRef b, uint64_t c) {return cl.copyFromRemoteBuffer(a, b, c);}); +JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, StringRef a, gccs::ArrayRef b, uint64_t c, unsigned int d) {return cl.copyFromRemoteBuffer(a, b, c, d);}); }{ using namespace poplar; -JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, std::string a, gccs::ArrayRef b, uint64_t c) {return cl.copyFromRemoteBuffer(a, b, c);}); -JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, std::string a, gccs::ArrayRef b, uint64_t c, unsigned int d) {return cl.copyFromRemoteBuffer(a, b, c, d);}); +JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, StringRef a, gccs::ArrayRef b, uint64_t c) {return cl.copyFromRemoteBuffer(a, b, c);}); +JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, StringRef a, gccs::ArrayRef b, uint64_t c, unsigned int d) {return cl.copyFromRemoteBuffer(a, b, c, d);}); }{ using namespace poplar; -JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, std::string a, gccs::ArrayRef b, uint64_t c) {return cl.copyFromRemoteBuffer(a, b, c);}); -JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, std::string a, gccs::ArrayRef b, uint64_t c, unsigned int d) {return cl.copyFromRemoteBuffer(a, b, c, d);}); +JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, StringRef a, gccs::ArrayRef b, uint64_t c) {return cl.copyFromRemoteBuffer(a, b, c);}); +JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, StringRef a, gccs::ArrayRef b, uint64_t c, unsigned int d) {return cl.copyFromRemoteBuffer(a, b, c, d);}); }{ using namespace poplar; -JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, std::string a, gccs::ArrayRef b, uint64_t c) {return cl.copyFromRemoteBuffer(a, b, c);}); -JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, std::string a, gccs::ArrayRef b, uint64_t c, unsigned int d) {return cl.copyFromRemoteBuffer(a, b, c, d);}); +JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, StringRef a, gccs::ArrayRef b, uint64_t c) {return cl.copyFromRemoteBuffer(a, b, c);}); +JLEngine.method("EngineCopyFromRemoteBuffer", [](poplar::Engine& cl, StringRef a, gccs::ArrayRef b, uint64_t c, unsigned int d) {return cl.copyFromRemoteBuffer(a, b, c, d);}); } -// poplar::Engine::copyToRemoteBuffer(void *, std::string, uint64_t, unsigned int)__CXXMethod +// poplar::Engine::copyToRemoteBuffer(void *, StringRef, uint64_t, unsigned int)__CXXMethod { using namespace poplar; -JLEngine.method("EngineCopyToRemoteBuffer", [](poplar::Engine& cl, void * a, std::string b, uint64_t c) {return cl.copyToRemoteBuffer(a, b, c);}); -JLEngine.method("EngineCopyToRemoteBuffer", [](poplar::Engine& cl, void * a, std::string b, uint64_t c, unsigned int d) {return cl.copyToRemoteBuffer(a, b, c, d);}); +JLEngine.method("EngineCopyToRemoteBuffer", [](poplar::Engine& cl, void * a, StringRef b, uint64_t c) {return cl.copyToRemoteBuffer(a, b, c);}); +JLEngine.method("EngineCopyToRemoteBuffer", [](poplar::Engine& cl, void * a, StringRef b, uint64_t c, unsigned int d) {return cl.copyToRemoteBuffer(a, b, c, d);}); +} +// poplar::Engine::copyToRemoteBuffer(ArrayRef, StringRef, uint64_t, unsigned int)__FunctionTemplate +{ using namespace poplar; +JLEngine.method("EngineCopyToRemoteBuffer", [](poplar::Engine& cl, jlcxx::ArrayRef a, StringRef b, uint64_t c) {return cl.copyToRemoteBuffer(jlcxxToPoplar(a), b, c);}); +JLEngine.method("EngineCopyToRemoteBuffer", [](poplar::Engine& cl, jlcxx::ArrayRef a, StringRef b, uint64_t c, unsigned int d) {return cl.copyToRemoteBuffer(jlcxxToPoplar(a), b, c, d);}); +}{ using namespace poplar; +JLEngine.method("EngineCopyToRemoteBuffer", [](poplar::Engine& cl, jlcxx::ArrayRef a, StringRef b, uint64_t c) {return cl.copyToRemoteBuffer(jlcxxToPoplar(a), b, c);}); +JLEngine.method("EngineCopyToRemoteBuffer", [](poplar::Engine& cl, jlcxx::ArrayRef a, StringRef b, uint64_t c, unsigned int d) {return cl.copyToRemoteBuffer(jlcxxToPoplar(a), b, c, d);}); +}{ using namespace poplar; +JLEngine.method("EngineCopyToRemoteBuffer", [](poplar::Engine& cl, jlcxx::ArrayRef a, StringRef b, uint64_t c) {return cl.copyToRemoteBuffer(jlcxxToPoplar(a), b, c);}); +JLEngine.method("EngineCopyToRemoteBuffer", [](poplar::Engine& cl, jlcxx::ArrayRef a, StringRef b, uint64_t c, unsigned int d) {return cl.copyToRemoteBuffer(jlcxxToPoplar(a), b, c, d);}); +}{ using namespace poplar; +JLEngine.method("EngineCopyToRemoteBuffer", [](poplar::Engine& cl, jlcxx::ArrayRef a, StringRef b, uint64_t c) {return cl.copyToRemoteBuffer(jlcxxToPoplar(a), b, c);}); +JLEngine.method("EngineCopyToRemoteBuffer", [](poplar::Engine& cl, jlcxx::ArrayRef a, StringRef b, uint64_t c, unsigned int d) {return cl.copyToRemoteBuffer(jlcxxToPoplar(a), b, c, d);}); +}{ using namespace poplar; +JLEngine.method("EngineCopyToRemoteBuffer", [](poplar::Engine& cl, jlcxx::ArrayRef a, StringRef b, uint64_t c) {return cl.copyToRemoteBuffer(jlcxxToPoplar(a), b, c);}); +JLEngine.method("EngineCopyToRemoteBuffer", [](poplar::Engine& cl, jlcxx::ArrayRef a, StringRef b, uint64_t c, unsigned int d) {return cl.copyToRemoteBuffer(jlcxxToPoplar(a), b, c, d);}); } // poplar::Engine::listStreams()__CXXMethod { using namespace poplar; @@ -2594,13 +2618,13 @@ JLEngine.method("EngineListStreams", [](poplar::Engine& cl) {return cl.listStrea { using namespace poplar; JLEngine.method("EngineGetEngineOptions", [](poplar::Engine& cl) {return cl.getEngineOptions();}); } -// poplar::Engine::insertSimulatedError(poplar::ErrorCode, const poplar::ErrorLocation &)__CXXMethod +// poplar::Engine::insertSimulatedError(ErrorCode, const ErrorLocation &)__CXXMethod { using namespace poplar; -JLEngine.method("EngineInsertSimulatedError", [](poplar::Engine& cl, poplar::ErrorCode a, const poplar::ErrorLocation & b) {return cl.insertSimulatedError(a, b);}); +JLEngine.method("EngineInsertSimulatedError", [](poplar::Engine& cl, ErrorCode a, const ErrorLocation & b) {return cl.insertSimulatedError(a, b);}); } -// poplar::Engine::eraseSimulatedError(const poplar::ErrorLocation &)__CXXMethod +// poplar::Engine::eraseSimulatedError(const ErrorLocation &)__CXXMethod { using namespace poplar; -JLEngine.method("EngineEraseSimulatedError", [](poplar::Engine& cl, const poplar::ErrorLocation & a) {return cl.eraseSimulatedError(a);}); +JLEngine.method("EngineEraseSimulatedError", [](poplar::Engine& cl, const ErrorLocation & a) {return cl.eraseSimulatedError(a);}); } // poplar::Engine::clearSimulatedErrors()__CXXMethod { using namespace poplar; @@ -2611,33 +2635,39 @@ JLEngine.method("EngineClearSimulatedErrors", [](poplar::Engine& cl) {return cl. JLEngine.method("EngineGetSimulatedErrorLocations", [](poplar::Engine& cl, unsigned int a) {return cl.getSimulatedErrorLocations(a);}); JLEngine.method("EngineGetSimulatedErrorLocations", [](poplar::Engine& cl, unsigned int a, unsigned int b) {return cl.getSimulatedErrorLocations(a, b);}); } -// poplar::Engine::getSimulatedErrorLocations(std::string, unsigned int)__CXXMethod +// poplar::Engine::getSimulatedErrorLocations(StringRef, unsigned int)__CXXMethod { using namespace poplar; -JLEngine.method("EngineGetSimulatedErrorLocations", [](poplar::Engine& cl, std::string a) {return cl.getSimulatedErrorLocations(a);}); -JLEngine.method("EngineGetSimulatedErrorLocations", [](poplar::Engine& cl, std::string a, unsigned int b) {return cl.getSimulatedErrorLocations(a, b);}); +JLEngine.method("EngineGetSimulatedErrorLocations", [](poplar::Engine& cl, StringRef a) {return cl.getSimulatedErrorLocations(a);}); +JLEngine.method("EngineGetSimulatedErrorLocations", [](poplar::Engine& cl, StringRef a, unsigned int b) {return cl.getSimulatedErrorLocations(a, b);}); } -// poplar::compileGraph(const poplar::Graph &, ArrayRef, const poplar::OptionFlags &, poplar::ProgressFunc, const poplar::DebugContext &)__FunctionDecl +// poplar::compileGraph(const Graph &, ArrayRef, const OptionFlags &, ProgressFunc, const DebugContext &)__FunctionDecl +{ using namespace poplar; +mod.method("PoplarCompileGraph", [](const Graph & a, ArrayRef b, const OptionFlags & c, ProgressFunc d, const DebugContext & e) {return poplar::compileGraph(a, b, c, d, e);} ); } +// poplar::compileModule(const Graph &, program::Program, const OptionFlags &, ProgressFunc, const DebugContext &)__FunctionDecl +{ using namespace poplar; +mod.method("PoplarCompileModule", [](const Graph & a, program::Program b, const OptionFlags & c, ProgressFunc d, const DebugContext & e) {return poplar::compileModule(a, b, c, d, e);} ); } +// poplar::compileModule(const Graph &, program::Program, const Preallocations &, const OptionFlags &, ProgressFunc, const DebugContext &)__FunctionDecl { using namespace poplar; -mod.method("PoplarCompileGraph", [](const poplar::Graph & a, ArrayRef b, const poplar::OptionFlags & c, poplar::ProgressFunc d, std::string e) {return poplar::compileGraph(a, b, c, d, e);} ); } -// poplar::compileModule(const poplar::Graph &, program::Program, const poplar::OptionFlags &, poplar::ProgressFunc, const poplar::DebugContext &)__FunctionDecl +mod.method("PoplarCompileModule", [](const Graph & a, program::Program b, const Preallocations & c, const OptionFlags & d, ProgressFunc e, const DebugContext & f) {return poplar::compileModule(a, b, c, d, e, f);} ); } +// poplar::compileGraph(const Graph &, ArrayRef, const Preallocations &, const OptionFlags &, ProgressFunc, const DebugContext &)__FunctionDecl { using namespace poplar; -mod.method("PoplarCompileModule", [](const poplar::Graph & a, program::Program b, const poplar::OptionFlags & c, poplar::ProgressFunc d, std::string e) {return poplar::compileModule(a, b, c, d, e);} ); } +mod.method("PoplarCompileGraph", [](const Graph & a, ArrayRef b, const Preallocations & c, const OptionFlags & d, ProgressFunc e, const DebugContext & f) {return poplar::compileGraph(a, b, c, d, e, f);} ); } // poplar::FloatingPointBehaviour::FloatingPointBehaviour(bool, bool, bool, bool, bool)__CXXConstructor { using namespace poplar; JLFloatingPointBehaviour.constructor(); } -// poplar::setFloatingPointBehaviour(poplar::Graph &, poplar::program::Sequence &, const poplar::FloatingPointBehaviour &, const poplar::DebugContext &)__FunctionDecl +// poplar::setFloatingPointBehaviour(poplar::Graph &, poplar::program::Sequence &, const FloatingPointBehaviour &, const DebugContext &)__FunctionDecl { using namespace poplar; -mod.method("PoplarSetFloatingPointBehaviour", [](poplar::Graph & a, poplar::program::Sequence & b, const poplar::FloatingPointBehaviour & c, std::string d) {return poplar::setFloatingPointBehaviour(a, b, c, d);} ); } -// poplar::setFloatingPointBehaviour(poplar::Graph &, poplar::program::Sequence &, const poplar::Tensor &, const poplar::DebugContext &)__FunctionDecl +mod.method("PoplarSetFloatingPointBehaviour", [](poplar::Graph & a, poplar::program::Sequence & b, const FloatingPointBehaviour & c, const DebugContext & d) {return poplar::setFloatingPointBehaviour(a, b, c, d);} ); } +// poplar::setFloatingPointBehaviour(poplar::Graph &, poplar::program::Sequence &, const poplar::Tensor &, const DebugContext &)__FunctionDecl { using namespace poplar; -mod.method("PoplarSetFloatingPointBehaviour", [](poplar::Graph & a, poplar::program::Sequence & b, const poplar::Tensor & c, std::string d) {return poplar::setFloatingPointBehaviour(a, b, c, d);} ); } -// poplar::setStochasticRounding(poplar::Graph &, poplar::program::Sequence &, bool, const poplar::DebugContext &)__FunctionDecl +mod.method("PoplarSetFloatingPointBehaviour", [](poplar::Graph & a, poplar::program::Sequence & b, const poplar::Tensor & c, const DebugContext & d) {return poplar::setFloatingPointBehaviour(a, b, c, d);} ); } +// poplar::setStochasticRounding(poplar::Graph &, poplar::program::Sequence &, bool, const DebugContext &)__FunctionDecl { using namespace poplar; -mod.method("PoplarSetStochasticRounding", [](poplar::Graph & a, poplar::program::Sequence & b, bool c, std::string d) {return poplar::setStochasticRounding(a, b, c, d);} ); } -// poplar::getAndModifyFloatingPointBehaviour(poplar::Graph &, poplar::program::Sequence &, const poplar::FloatingPointBehaviour &, const poplar::FloatingPointBehaviour &, const poplar::DebugContext &)__FunctionDecl +mod.method("PoplarSetStochasticRounding", [](poplar::Graph & a, poplar::program::Sequence & b, bool c, const DebugContext & d) {return poplar::setStochasticRounding(a, b, c, d);} ); } +// poplar::getAndModifyFloatingPointBehaviour(poplar::Graph &, poplar::program::Sequence &, const FloatingPointBehaviour &, const FloatingPointBehaviour &, const DebugContext &)__FunctionDecl { using namespace poplar; -mod.method("PoplarGetAndModifyFloatingPointBehaviour", [](poplar::Graph & a, poplar::program::Sequence & b, const poplar::FloatingPointBehaviour & c, const poplar::FloatingPointBehaviour & d, std::string e) {return poplar::getAndModifyFloatingPointBehaviour(a, b, c, d, e);} ); } +mod.method("PoplarGetAndModifyFloatingPointBehaviour", [](poplar::Graph & a, poplar::program::Sequence & b, const FloatingPointBehaviour & c, const FloatingPointBehaviour & d, const DebugContext & e) {return poplar::getAndModifyFloatingPointBehaviour(a, b, c, d, e);} ); } // poplar::IPUModel::IPUModel(const char *)__CXXConstructor { using namespace poplar; JLIPUModel.constructor(); @@ -2646,12 +2676,12 @@ JLIPUModel.constructor(); mod.set_const("IPUModelRelativeSyncDelayTypeIPUModelAUTO", poplar::IPUModel::RelativeSyncDelayType::AUTO); // poplar::IPUModel::RelativeSyncDelayType::NO_DELAY__EnumConstantDecl mod.set_const("IPUModelRelativeSyncDelayTypeIPUModelNO_DELAY", poplar::IPUModel::RelativeSyncDelayType::NO_DELAY); -// poplar::IPUModel::createDevice(poplar::OptionFlags, bool, unsigned int)__CXXMethod +// poplar::IPUModel::createDevice(OptionFlags, bool, unsigned int)__CXXMethod { using namespace poplar; JLIPUModel.method("IPUModelCreateDevice", [](poplar::IPUModel& cl) {return cl.createDevice();}); -JLIPUModel.method("IPUModelCreateDevice", [](poplar::IPUModel& cl, poplar::OptionFlags a) {return cl.createDevice(a);}); -JLIPUModel.method("IPUModelCreateDevice", [](poplar::IPUModel& cl, poplar::OptionFlags a, bool b) {return cl.createDevice(a, b);}); -JLIPUModel.method("IPUModelCreateDevice", [](poplar::IPUModel& cl, poplar::OptionFlags a, bool b, unsigned int c) {return cl.createDevice(a, b, c);}); +JLIPUModel.method("IPUModelCreateDevice", [](poplar::IPUModel& cl, OptionFlags a) {return cl.createDevice(a);}); +JLIPUModel.method("IPUModelCreateDevice", [](poplar::IPUModel& cl, OptionFlags a, bool b) {return cl.createDevice(a, b);}); +JLIPUModel.method("IPUModelCreateDevice", [](poplar::IPUModel& cl, OptionFlags a, bool b, unsigned int c) {return cl.createDevice(a, b, c);}); } // popops::varianceToInvStdDev(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::Type, const poplar::DebugContext &)__FunctionDecl { using namespace popops; From 0270e5860a54b4986eba8f61997d6e6691a3c3b8 Mon Sep 17 00:00:00 2001 From: Gnimuc Date: Tue, 20 Aug 2024 23:24:28 +0900 Subject: [PATCH 4/6] 3.3 --- deps/wrapper/gen_inherit.cpp | 1 + deps/wrapper/gen_inline.cpp | 578 ++++++++++++++++++++--------------- 2 files changed, 340 insertions(+), 239 deletions(-) diff --git a/deps/wrapper/gen_inherit.cpp b/deps/wrapper/gen_inherit.cpp index 18d7ddf..a4ffde3 100644 --- a/deps/wrapper/gen_inherit.cpp +++ b/deps/wrapper/gen_inherit.cpp @@ -13,6 +13,7 @@ template<> struct SuperType { typedef poplar::poplar_ template<> struct SuperType { typedef poplar::poplar_error type; }; template<> struct SuperType { typedef poplar::poplar_error type; }; template<> struct SuperType { typedef poplar::poplar_error type; }; +template<> struct SuperType { typedef poplar::poplar_error type; }; template<> struct SuperType { typedef poplar::poplar_error type; }; template<> struct SuperType { typedef poplar::poplar_error type; }; template<> struct SuperType { typedef poplar::poplar_error type; }; diff --git a/deps/wrapper/gen_inline.cpp b/deps/wrapper/gen_inline.cpp index 961b020..57b83f8 100644 --- a/deps/wrapper/gen_inline.cpp +++ b/deps/wrapper/gen_inline.cpp @@ -106,6 +106,8 @@ auto JLGraph_recursion_error = mod.add_type("Grap auto JLGraph_replication_error = mod.add_type("Graph_replication_error", jlcxx::julia_base_type()); // poplar::profiling_disabled__StructDecl auto JLProfiling_disabled = mod.add_type("Profiling_disabled", jlcxx::julia_base_type()); +// poplar::missing_profile_data__StructDecl +auto JLMissing_profile_data = mod.add_type("Missing_profile_data", jlcxx::julia_base_type()); // poplar::missing_graph_profile__StructDecl auto JLMissing_graph_profile = mod.add_type("Missing_graph_profile", jlcxx::julia_base_type()); // poplar::missing_perf_estimate__StructDecl @@ -162,6 +164,10 @@ auto JLVertexEdgeInfo = mod.add_type("VertexEdgeInfo"); auto JLVertexEdgeInfoStorageInfo = mod.add_type("VertexEdgeInfoStorageInfo"); // poplar::VertexPerfEstimate__StructDecl mod.map_type("VertexPerfEstimate"); +// poplar::PrintTensorFmt__ClassDecl +auto JLPrintTensorFmt = mod.add_type("PrintTensorFmt"); +// poplar::PrintTensorFmt::FloatFormat__EnumDecl +mod.add_bits("PrintTensorFmtFloatFormat", jlcxx::julia_type("CppEnum")); // poplar::SyncType__EnumDecl mod.add_bits("PoplarSyncType", jlcxx::julia_type("CppEnum")); // poplar::TypeTraits__StructDecl @@ -334,6 +340,14 @@ JLOptionFlags.method("OptionFlagsSet", [](poplar::OptionFlags& cl, StringRef a, { using namespace poplar; JLOptionFlags.method("OptionFlagsAt", [](poplar::OptionFlags& cl, StringRef a) {return cl.at(a);}); } +// poplar::OptionFlags::find(const StringRef)__CXXMethod +{ using namespace poplar; +JLOptionFlags.method("OptionFlagsFind", [](poplar::OptionFlags& cl, const StringRef a) {return cl.find(a);}); +} +// poplar::OptionFlags::size()__CXXMethod +{ using namespace poplar; +JLOptionFlags.method("OptionFlagsSize", [](poplar::OptionFlags& cl) {return cl.size();}); +} // poplar::OptionFlags::clear()__CXXMethod { using namespace poplar; JLOptionFlags.method("OptionFlagsClear", [](poplar::OptionFlags& cl) {return cl.clear();}); @@ -373,6 +387,8 @@ mod.set_const("PoplarIpuLinkConfigurationPoplarBarleyTwist", poplar::IpuLinkConf mod.set_const("PoplarIpuLinkTopologyPoplarMesh", poplar::IpuLinkTopology::Mesh); // poplar::IpuLinkTopology::Torus__EnumConstantDecl mod.set_const("PoplarIpuLinkTopologyPoplarTorus", poplar::IpuLinkTopology::Torus); +// poplar::IpuLinkTopology::Line__EnumConstantDecl +mod.set_const("PoplarIpuLinkTopologyPoplarLine", poplar::IpuLinkTopology::Line); // poplar::TargetType::IPU__EnumConstantDecl mod.set_const("PoplarTargetTypePoplarIPU", poplar::TargetType::IPU); // poplar::TargetType::IPU_MODEL__EnumConstantDecl @@ -656,6 +672,14 @@ JLTarget.method("TargetCreateIPUTarget", [](poplar::Target& cl, unsigned int a, JLTarget.method("TargetCreateIPUTarget", [](poplar::Target& cl, unsigned int a, unsigned int b, StringRef c) {return cl.createIPUTarget(a, b, c);}); JLTarget.method("TargetCreateIPUTarget", [](poplar::Target& cl, unsigned int a, unsigned int b, StringRef c, const OptionFlags & d) {return cl.createIPUTarget(a, b, c, d);}); } +// poplar::Target::getTypeLimitsMaxAs<>(const Type &)__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetTypeLimitsMaxAs<>", [](poplar::Target& cl, const Type & a) {return cl.getTypeLimitsMaxAs<>(a);}); +} +// poplar::Target::getTypeLimitsLowestAs<>(const Type &)__CXXMethod +{ using namespace poplar; +JLTarget.method("TargetGetTypeLimitsLowestAs<>", [](poplar::Target& cl, const Type & a) {return cl.getTypeLimitsLowestAs<>(a);}); +} // poplar::copyDeviceHalfToFloat(const Target &, const void *, float *, std::size_t)__FunctionDecl { using namespace poplar; mod.method("PoplarCopyDeviceHalfToFloat", [](const Target & a, const void * b, float * c, std::size_t d) {return poplar::copyDeviceHalfToFloat(a, b, c, d);} ); } @@ -680,6 +704,10 @@ JLDevice.method("DeviceGetTarget", [](poplar::Device& cl) {return cl.getTarget() { using namespace poplar; JLDevice.method("DeviceAttach", [](poplar::Device& cl) {return cl.attach();}); } +// poplar::Device::isAttached()__CXXMethod +{ using namespace poplar; +JLDevice.method("DeviceIsAttached", [](poplar::Device& cl) {return cl.isAttached();}); +} // poplar::Device::detach()__CXXMethod { using namespace poplar; JLDevice.method("DeviceDetach", [](poplar::Device& cl) {return cl.detach();}); @@ -1416,6 +1444,8 @@ JLSystem_runtime_error.constructor(); } // poplar::RecoveryAction::IPU_RESET__EnumConstantDecl mod.set_const("PoplarRecoveryActionPoplarIPU_RESET", poplar::RecoveryAction::IPU_RESET); +// poplar::RecoveryAction::LINK_RESET__EnumConstantDecl +mod.set_const("PoplarRecoveryActionPoplarLINK_RESET", poplar::RecoveryAction::LINK_RESET); // poplar::RecoveryAction::PARTITION_RESET__EnumConstantDecl mod.set_const("PoplarRecoveryActionPoplarPARTITION_RESET", poplar::RecoveryAction::PARTITION_RESET); // poplar::RecoveryAction::FULL_RESET__EnumConstantDecl @@ -1464,6 +1494,33 @@ JLParse_error.constructor(); { using namespace poplar; JLParse_error.constructor(); } +// poplar::PrintTensorFmt::FloatFormat::Auto__EnumConstantDecl +mod.set_const("PrintTensorFmtFloatFormatPrintTensorFmtAuto", poplar::PrintTensorFmt::FloatFormat::Auto); +// poplar::PrintTensorFmt::FloatFormat::Fixed__EnumConstantDecl +mod.set_const("PrintTensorFmtFloatFormatPrintTensorFmtFixed", poplar::PrintTensorFmt::FloatFormat::Fixed); +// poplar::PrintTensorFmt::FloatFormat::Scientific__EnumConstantDecl +mod.set_const("PrintTensorFmtFloatFormatPrintTensorFmtScientific", poplar::PrintTensorFmt::FloatFormat::Scientific); +// poplar::PrintTensorFmt::FloatFormat::None__EnumConstantDecl +mod.set_const("PrintTensorFmtFloatFormatPrintTensorFmtNone", poplar::PrintTensorFmt::FloatFormat::None); +// poplar::PrintTensorFmt::PrintTensorFmt(unsigned int, unsigned int, unsigned int, unsigned int, FloatFormat, char, char, char)__CXXConstructor +{ using namespace poplar; +JLPrintTensorFmt.constructor(); +JLPrintTensorFmt.constructor(); +JLPrintTensorFmt.constructor(); +JLPrintTensorFmt.constructor(); +JLPrintTensorFmt.constructor(); +JLPrintTensorFmt.constructor(); +JLPrintTensorFmt.constructor(); +JLPrintTensorFmt.constructor(); +} +// poplar::PrintTensorFmt::disableFormatting()__CXXMethod +{ using namespace poplar; +JLPrintTensorFmt.method("PrintTensorFmtDisableFormatting", [](poplar::PrintTensorFmt& cl) {return cl.disableFormatting();}); +} +// poplar::PrintTensorFmt::PrintTensorFmt(const PrintTensorFmt &)__CXXConstructor +{ using namespace poplar; +JLPrintTensorFmt.constructor(); +} // poplar::SyncType::INTERNAL__EnumConstantDecl mod.set_const("PoplarSyncTypePoplarINTERNAL", poplar::SyncType::INTERNAL); // poplar::SyncType::EXTERNAL__EnumConstantDecl @@ -1840,6 +1897,16 @@ JLProgramCall.constructor(); JLProgramCall.constructor, jlcxx::ArrayRef>(); JLProgramCall.constructor, jlcxx::ArrayRef, const DebugContext &>(); } +// poplar::program::PrintTensor::PrintTensor(Tensor, const PrintTensorFmt &, const DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramPrintTensor.constructor(); +JLProgramPrintTensor.constructor(); +} +// poplar::program::PrintTensor::PrintTensor(StringRef, Tensor, const PrintTensorFmt &, const DebugContext &)__CXXConstructor +{ using namespace poplar::program; +JLProgramPrintTensor.constructor(); +JLProgramPrintTensor.constructor(); +} // poplar::program::PrintTensor::PrintTensor(Tensor, const DebugContext &)__CXXConstructor { using namespace poplar::program; JLProgramPrintTensor.constructor(); @@ -2402,6 +2469,10 @@ JLGraph.method("GraphConvertPhysicalTileToVirtualTile", [](poplar::Graph& cl, un { using namespace poplar; JLGraph.method("GraphHasCodelet", [](poplar::Graph& cl, StringRef a) {return cl.hasCodelet(a);}); } +// poplar::Graph::getMaxVertexFieldValueAs<>(StringRef, StringRef)__CXXMethod +{ using namespace poplar; +JLGraph.method("GraphGetMaxVertexFieldValueAs<>", [](poplar::Graph& cl, StringRef a, StringRef b) {return cl.getMaxVertexFieldValueAs<>(a, b);}); +} // poplar::RuntimeOptions::RuntimeOptions(const OptionFlags &)__CXXConstructor { using namespace poplar; JLRuntimeOptions.constructor(); @@ -2468,6 +2539,11 @@ JLEngine.constructor(); JLEngine.constructor(); JLEngine.constructor(); } +// poplar::Engine::Engine(const Executable &, const OptionFlags &)__CXXConstructor +{ using namespace poplar; +JLEngine.constructor(); +JLEngine.constructor(); +} // poplar::Engine::prepare(const Device &)__CXXMethod { using namespace poplar; JLEngine.method("EnginePrepare", [](poplar::Engine& cl, const Device & a) {return cl.prepare(a);}); @@ -2643,6 +2719,9 @@ JLEngine.method("EngineGetSimulatedErrorLocations", [](poplar::Engine& cl, Strin // poplar::compileGraph(const Graph &, ArrayRef, const OptionFlags &, ProgressFunc, const DebugContext &)__FunctionDecl { using namespace poplar; mod.method("PoplarCompileGraph", [](const Graph & a, ArrayRef b, const OptionFlags & c, ProgressFunc d, const DebugContext & e) {return poplar::compileGraph(a, b, c, d, e);} ); } +// poplar::compileGraph(const Graph &, ArrayRef, bool, const OptionFlags &, ProgressFunc, const DebugContext &)__FunctionDecl +{ using namespace poplar; +mod.method("PoplarCompileGraph", [](const Graph & a, ArrayRef b, bool c, const OptionFlags & d, ProgressFunc e, const DebugContext & f) {return poplar::compileGraph(a, b, c, d, e, f);} ); } // poplar::compileModule(const Graph &, program::Program, const OptionFlags &, ProgressFunc, const DebugContext &)__FunctionDecl { using namespace poplar; mod.method("PoplarCompileModule", [](const Graph & a, program::Program b, const OptionFlags & c, ProgressFunc d, const DebugContext & e) {return poplar::compileModule(a, b, c, d, e);} ); } @@ -2652,6 +2731,9 @@ mod.method("PoplarCompileModule", [](const Graph & a, program::Program b, const // poplar::compileGraph(const Graph &, ArrayRef, const Preallocations &, const OptionFlags &, ProgressFunc, const DebugContext &)__FunctionDecl { using namespace poplar; mod.method("PoplarCompileGraph", [](const Graph & a, ArrayRef b, const Preallocations & c, const OptionFlags & d, ProgressFunc e, const DebugContext & f) {return poplar::compileGraph(a, b, c, d, e, f);} ); } +// poplar::compileGraph(const Graph &, ArrayRef, const Preallocations &, bool, const OptionFlags &, ProgressFunc, const DebugContext &)__FunctionDecl +{ using namespace poplar; +mod.method("PoplarCompileGraph", [](const Graph & a, ArrayRef b, const Preallocations & c, bool d, const OptionFlags & e, ProgressFunc f, const DebugContext & g) {return poplar::compileGraph(a, b, c, d, e, f, g);} ); } // poplar::FloatingPointBehaviour::FloatingPointBehaviour(bool, bool, bool, bool, bool)__CXXConstructor { using namespace poplar; JLFloatingPointBehaviour.constructor(); @@ -2683,18 +2765,6 @@ JLIPUModel.method("IPUModelCreateDevice", [](poplar::IPUModel& cl, OptionFlags a JLIPUModel.method("IPUModelCreateDevice", [](poplar::IPUModel& cl, OptionFlags a, bool b) {return cl.createDevice(a, b);}); JLIPUModel.method("IPUModelCreateDevice", [](poplar::IPUModel& cl, OptionFlags a, bool b, unsigned int c) {return cl.createDevice(a, b, c);}); } -// popops::varianceToInvStdDev(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::Type, const poplar::DebugContext &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsVarianceToInvStdDev", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, const poplar::Type e, std::string f) {return popops::varianceToInvStdDev(a, b, c, d, e, f);} ); } -// popops::varianceToInvStdDev(poplar::Graph &, const poplar::Tensor &, const float, poplar::program::Sequence &, const poplar::Type, const poplar::DebugContext &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsVarianceToInvStdDev", [](poplar::Graph & a, const poplar::Tensor & b, const float c, poplar::program::Sequence & d, const poplar::Type e, std::string f) {return popops::varianceToInvStdDev(a, b, c, d, e, f);} ); } -// popops::invStdDevToVariance(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::Type, const poplar::DebugContext &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsInvStdDevToVariance", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, const poplar::Type e, std::string f) {return popops::invStdDevToVariance(a, b, c, d, e, f);} ); } -// popops::invStdDevToVariance(poplar::Graph &, const poplar::Tensor &, const float, poplar::program::Sequence &, const poplar::Type, const poplar::DebugContext &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsInvStdDevToVariance", [](poplar::Graph & a, const poplar::Tensor & b, const float c, poplar::program::Sequence & d, const poplar::Type e, std::string f) {return popops::invStdDevToVariance(a, b, c, d, e, f);} ); } // popops::abs(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; mod.method("PopopsAbs", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::abs(a, b, c, d, e);} ); } @@ -2704,15 +2774,54 @@ mod.method("PopopsAbsInPlace", [](poplar::Graph & a, const poplar::Tensor & b, p // popops::absWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; mod.method("PopopsAbsWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::absWithOutput(a, b, c, d, e, f);} ); } -// popops::asin(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +// popops::inv(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsAsin", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::asin(a, b, c, d, e);} ); } -// popops::asinInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsInv", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::inv(a, b, c, d, e);} ); } +// popops::invInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsAsinInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::asinInPlace(a, b, c, d, e);} ); } -// popops::asinWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsInvInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::invInPlace(a, b, c, d, e);} ); } +// popops::invWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsAsinWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::asinWithOutput(a, b, c, d, e, f);} ); } +mod.method("PopopsInvWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::invWithOutput(a, b, c, d, e, f);} ); } +// popops::logicalNot(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLogicalNot", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::logicalNot(a, b, c, d, e);} ); } +// popops::logicalNotInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLogicalNotInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::logicalNotInPlace(a, b, c, d, e);} ); } +// popops::logicalNotWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLogicalNotWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::logicalNotWithOutput(a, b, c, d, e, f);} ); } +// popops::neg(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsNeg", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::neg(a, b, c, d, e);} ); } +// popops::negInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsNegInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::negInPlace(a, b, c, d, e);} ); } +// popops::negWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsNegWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::negWithOutput(a, b, c, d, e, f);} ); } +// popops::signum(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsSignum", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::signum(a, b, c, d, e);} ); } +// popops::signumInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsSignumInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::signumInPlace(a, b, c, d, e);} ); } +// popops::signumWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsSignumWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::signumWithOutput(a, b, c, d, e, f);} ); } +// popops::isFinite(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsIsFinite", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::isFinite(a, b, c, d, e);} ); } +// popops::isFiniteWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsIsFiniteWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::isFiniteWithOutput(a, b, c, d, e, f);} ); } +// popops::checkTypes<>(poplar::Type, float)__FunctionDecl +{ using namespace popops; +mod.method("PopopsCheckTypes<>", [](poplar::Type a, float b) {return popops::checkTypes<>(a, b);} ); } +// popops::checkTypes<>(poplar::Type, double)__FunctionDecl +{ using namespace popops; +mod.method("PopopsCheckTypes<>", [](poplar::Type a, double b) {return popops::checkTypes<>(a, b);} ); } // popops::bitwiseNot(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; mod.method("PopopsBitwiseNot", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::bitwiseNot(a, b, c, d, e);} ); } @@ -2722,24 +2831,24 @@ mod.method("PopopsBitwiseNotInPlace", [](poplar::Graph & a, const poplar::Tensor // popops::bitwiseNotWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; mod.method("PopopsBitwiseNotWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::bitwiseNotWithOutput(a, b, c, d, e, f);} ); } -// popops::cbrt(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +// popops::countLeadingZeros(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsCbrt", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::cbrt(a, b, c, d, e);} ); } -// popops::cbrtInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsCountLeadingZeros", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::countLeadingZeros(a, b, c, d, e);} ); } +// popops::countLeadingZerosInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsCbrtInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::cbrtInPlace(a, b, c, d, e);} ); } -// popops::cbrtWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsCountLeadingZerosInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::countLeadingZerosInPlace(a, b, c, d, e);} ); } +// popops::countLeadingZerosWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsCbrtWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::cbrtWithOutput(a, b, c, d, e, f);} ); } -// popops::geluErf(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsCountLeadingZerosWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::countLeadingZerosWithOutput(a, b, c, d, e, f);} ); } +// popops::popcount(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsGeluErf", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::geluErf(a, b, c, d, e);} ); } -// popops::geluErfInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsPopcount", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::popcount(a, b, c, d, e);} ); } +// popops::popcountInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsGeluErfInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::geluErfInPlace(a, b, c, d, e);} ); } -// popops::geluErfWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsPopcountInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::popcountInPlace(a, b, c, d, e);} ); } +// popops::popcountWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsGeluErfWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::geluErfWithOutput(a, b, c, d, e, f);} ); } +mod.method("PopopsPopcountWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::popcountWithOutput(a, b, c, d, e, f);} ); } // popops::ceil(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; mod.method("PopopsCeil", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::ceil(a, b, c, d, e);} ); } @@ -2749,33 +2858,42 @@ mod.method("PopopsCeilInPlace", [](poplar::Graph & a, const poplar::Tensor & b, // popops::ceilWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; mod.method("PopopsCeilWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::ceilWithOutput(a, b, c, d, e, f);} ); } -// popops::countLeadingZeros(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +// popops::floor(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsCountLeadingZeros", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::countLeadingZeros(a, b, c, d, e);} ); } -// popops::countLeadingZerosInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsFloor", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::floor(a, b, c, d, e);} ); } +// popops::floorInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsCountLeadingZerosInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::countLeadingZerosInPlace(a, b, c, d, e);} ); } -// popops::countLeadingZerosWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsFloorInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::floorInPlace(a, b, c, d, e);} ); } +// popops::floorWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsCountLeadingZerosWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::countLeadingZerosWithOutput(a, b, c, d, e, f);} ); } -// popops::cos(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsFloorWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::floorWithOutput(a, b, c, d, e, f);} ); } +// popops::round(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsCos", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::cos(a, b, c, d, e);} ); } -// popops::cosInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsRound", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::round(a, b, c, d, e);} ); } +// popops::roundInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsCosInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::cosInPlace(a, b, c, d, e);} ); } -// popops::cosWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsRoundInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::roundInPlace(a, b, c, d, e);} ); } +// popops::roundWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsCosWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::cosWithOutput(a, b, c, d, e, f);} ); } -// popops::erf(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsRoundWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::roundWithOutput(a, b, c, d, e, f);} ); } +// popops::nearbyint(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsErf", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::erf(a, b, c, d, e);} ); } -// popops::erfInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsNearbyint", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::nearbyint(a, b, c, d, e);} ); } +// popops::nearbyintInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsErfInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::erfInPlace(a, b, c, d, e);} ); } -// popops::erfWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsNearbyintInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::nearbyintInPlace(a, b, c, d, e);} ); } +// popops::nearbyintWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsErfWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::erfWithOutput(a, b, c, d, e, f);} ); } +mod.method("PopopsNearbyintWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::nearbyintWithOutput(a, b, c, d, e, f);} ); } +// popops::cbrt(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsCbrt", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::cbrt(a, b, c, d, e);} ); } +// popops::cbrtInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsCbrtInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::cbrtInPlace(a, b, c, d, e);} ); } +// popops::cbrtWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsCbrtWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::cbrtWithOutput(a, b, c, d, e, f);} ); } // popops::exp(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; mod.method("PopopsExp", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::exp(a, b, c, d, e);} ); } @@ -2785,6 +2903,15 @@ mod.method("PopopsExpInPlace", [](poplar::Graph & a, const poplar::Tensor & b, p // popops::expWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; mod.method("PopopsExpWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::expWithOutput(a, b, c, d, e, f);} ); } +// popops::exp2(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsExp2", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::exp2(a, b, c, d, e);} ); } +// popops::exp2InPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsExp2InPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::exp2InPlace(a, b, c, d, e);} ); } +// popops::exp2WithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsExp2WithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::exp2WithOutput(a, b, c, d, e, f);} ); } // popops::expm1(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; mod.method("PopopsExpm1", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::expm1(a, b, c, d, e);} ); } @@ -2794,24 +2921,6 @@ mod.method("PopopsExpm1InPlace", [](poplar::Graph & a, const poplar::Tensor & b, // popops::expm1WithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; mod.method("PopopsExpm1WithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::expm1WithOutput(a, b, c, d, e, f);} ); } -// popops::floor(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsFloor", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::floor(a, b, c, d, e);} ); } -// popops::floorInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsFloorInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::floorInPlace(a, b, c, d, e);} ); } -// popops::floorWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsFloorWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::floorWithOutput(a, b, c, d, e, f);} ); } -// popops::inv(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsInv", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::inv(a, b, c, d, e);} ); } -// popops::invInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsInvInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::invInPlace(a, b, c, d, e);} ); } -// popops::invWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsInvWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::invWithOutput(a, b, c, d, e, f);} ); } // popops::log(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; mod.method("PopopsLog", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::log(a, b, c, d, e);} ); } @@ -2830,42 +2939,60 @@ mod.method("PopopsLog1PInPlace", [](poplar::Graph & a, const poplar::Tensor & b, // popops::log1pWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; mod.method("PopopsLog1PWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::log1pWithOutput(a, b, c, d, e, f);} ); } -// popops::logicalNot(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +// popops::sqrt(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsLogicalNot", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::logicalNot(a, b, c, d, e);} ); } -// popops::logicalNotInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsSqrt", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::sqrt(a, b, c, d, e);} ); } +// popops::sqrtInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsLogicalNotInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::logicalNotInPlace(a, b, c, d, e);} ); } -// popops::logicalNotWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsSqrtInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::sqrtInPlace(a, b, c, d, e);} ); } +// popops::sqrtWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsLogicalNotWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::logicalNotWithOutput(a, b, c, d, e, f);} ); } -// popops::neg(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsSqrtWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::sqrtWithOutput(a, b, c, d, e, f);} ); } +// popops::square(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsNeg", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::neg(a, b, c, d, e);} ); } -// popops::negInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsSquare", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::square(a, b, c, d, e);} ); } +// popops::squareInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsNegInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::negInPlace(a, b, c, d, e);} ); } -// popops::negWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsSquareInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::squareInPlace(a, b, c, d, e);} ); } +// popops::squareWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsNegWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::negWithOutput(a, b, c, d, e, f);} ); } -// popops::popcount(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsSquareWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::squareWithOutput(a, b, c, d, e, f);} ); } +// popops::rsqrt(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsPopcount", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::popcount(a, b, c, d, e);} ); } -// popops::popcountInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsRsqrt", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::rsqrt(a, b, c, d, e);} ); } +// popops::rsqrtInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsPopcountInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::popcountInPlace(a, b, c, d, e);} ); } -// popops::popcountWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsRsqrtInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::rsqrtInPlace(a, b, c, d, e);} ); } +// popops::rsqrtWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsPopcountWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::popcountWithOutput(a, b, c, d, e, f);} ); } -// popops::signum(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsRsqrtWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::rsqrtWithOutput(a, b, c, d, e, f);} ); } +// popops::sigmoid(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsSignum", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::signum(a, b, c, d, e);} ); } -// popops::signumInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsSigmoid", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::sigmoid(a, b, c, d, e);} ); } +// popops::sigmoidInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsSignumInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::signumInPlace(a, b, c, d, e);} ); } -// popops::signumWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsSigmoidInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::sigmoidInPlace(a, b, c, d, e);} ); } +// popops::sigmoidWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsSignumWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::signumWithOutput(a, b, c, d, e, f);} ); } +mod.method("PopopsSigmoidWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::sigmoidWithOutput(a, b, c, d, e, f);} ); } +// popops::asin(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsAsin", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::asin(a, b, c, d, e);} ); } +// popops::asinInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsAsinInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::asinInPlace(a, b, c, d, e);} ); } +// popops::asinWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsAsinWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::asinWithOutput(a, b, c, d, e, f);} ); } +// popops::cos(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsCos", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::cos(a, b, c, d, e);} ); } +// popops::cosInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsCosInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::cosInPlace(a, b, c, d, e);} ); } +// popops::cosWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsCosWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::cosWithOutput(a, b, c, d, e, f);} ); } // popops::sin(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; mod.method("PopopsSin", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::sin(a, b, c, d, e);} ); } @@ -2893,81 +3020,90 @@ mod.method("PopopsTanhInPlace", [](poplar::Graph & a, const poplar::Tensor & b, // popops::tanhWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; mod.method("PopopsTanhWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::tanhWithOutput(a, b, c, d, e, f);} ); } -// popops::round(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +// popops::varianceToInvStdDev(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::Type, const poplar::DebugContext &)__FunctionDecl { using namespace popops; -mod.method("PopopsRound", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::round(a, b, c, d, e);} ); } -// popops::roundInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsVarianceToInvStdDev", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, const poplar::Type e, std::string f) {return popops::varianceToInvStdDev(a, b, c, d, e, f);} ); } +// popops::varianceToInvStdDev(poplar::Graph &, const poplar::Tensor &, const float, poplar::program::Sequence &, const poplar::Type, const poplar::DebugContext &)__FunctionDecl { using namespace popops; -mod.method("PopopsRoundInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::roundInPlace(a, b, c, d, e);} ); } -// popops::roundWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsVarianceToInvStdDev", [](poplar::Graph & a, const poplar::Tensor & b, const float c, poplar::program::Sequence & d, const poplar::Type e, std::string f) {return popops::varianceToInvStdDev(a, b, c, d, e, f);} ); } +// popops::invStdDevToVariance(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::Type, const poplar::DebugContext &)__FunctionDecl { using namespace popops; -mod.method("PopopsRoundWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::roundWithOutput(a, b, c, d, e, f);} ); } -// popops::sqrt(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsInvStdDevToVariance", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, const poplar::Type e, std::string f) {return popops::invStdDevToVariance(a, b, c, d, e, f);} ); } +// popops::invStdDevToVariance(poplar::Graph &, const poplar::Tensor &, const float, poplar::program::Sequence &, const poplar::Type, const poplar::DebugContext &)__FunctionDecl { using namespace popops; -mod.method("PopopsSqrt", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::sqrt(a, b, c, d, e);} ); } -// popops::sqrtInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsInvStdDevToVariance", [](poplar::Graph & a, const poplar::Tensor & b, const float c, poplar::program::Sequence & d, const poplar::Type e, std::string f) {return popops::invStdDevToVariance(a, b, c, d, e, f);} ); } +// popops::geluErf(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsSqrtInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::sqrtInPlace(a, b, c, d, e);} ); } -// popops::sqrtWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsGeluErf", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::geluErf(a, b, c, d, e);} ); } +// popops::geluErfInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsSqrtWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::sqrtWithOutput(a, b, c, d, e, f);} ); } -// popops::square(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsGeluErfInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::geluErfInPlace(a, b, c, d, e);} ); } +// popops::geluErfWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsSquare", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::square(a, b, c, d, e);} ); } -// popops::squareInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsGeluErfWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::geluErfWithOutput(a, b, c, d, e, f);} ); } +// popops::erf(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsSquareInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::squareInPlace(a, b, c, d, e);} ); } -// popops::squareWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsErf", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::erf(a, b, c, d, e);} ); } +// popops::erfInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsSquareWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::squareWithOutput(a, b, c, d, e, f);} ); } -// popops::sigmoid(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsErfInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::erfInPlace(a, b, c, d, e);} ); } +// popops::erfWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsSigmoid", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::sigmoid(a, b, c, d, e);} ); } -// popops::sigmoidInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsErfWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::erfWithOutput(a, b, c, d, e, f);} ); } +// popops::add(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsSigmoidInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::sigmoidInPlace(a, b, c, d, e);} ); } -// popops::sigmoidWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsAdd", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::add(a, b, c, d, e, f);} ); } +// popops::addInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsSigmoidWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::sigmoidWithOutput(a, b, c, d, e, f);} ); } -// popops::rsqrt(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsAddInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::addInPlace(a, b, c, d, e, f);} ); } +// popops::addWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsRsqrt", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::rsqrt(a, b, c, d, e);} ); } -// popops::rsqrtInPlace(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsAddWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::addWithOutput(a, b, c, d, e, f, g);} ); } +// popops::sub(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsRsqrtInPlace", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::rsqrtInPlace(a, b, c, d, e);} ); } -// popops::rsqrtWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsSub", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::sub(a, b, c, d, e, f);} ); } +// popops::subInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsRsqrtWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::rsqrtWithOutput(a, b, c, d, e, f);} ); } -// popops::isFinite(poplar::Graph &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsSubInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::subInPlace(a, b, c, d, e, f);} ); } +// popops::subWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsIsFinite", [](poplar::Graph & a, const poplar::Tensor & b, poplar::program::Sequence & c, std::string d, const poplar::OptionFlags & e) {return popops::isFinite(a, b, c, d, e);} ); } -// popops::isFiniteWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsSubWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::subWithOutput(a, b, c, d, e, f, g);} ); } +// popops::mul(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsIsFiniteWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::isFiniteWithOutput(a, b, c, d, e, f);} ); } -// popops::checkTypes<>(poplar::Type, float)__FunctionDecl +mod.method("PopopsMul", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::mul(a, b, c, d, e, f);} ); } +// popops::mulInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsCheckTypes<>", [](poplar::Type a, float b) {return popops::checkTypes<>(a, b);} ); } -// popops::checkTypes<>(poplar::Type, double)__FunctionDecl +mod.method("PopopsMulInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::mulInPlace(a, b, c, d, e, f);} ); } +// popops::mulWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsCheckTypes<>", [](poplar::Type a, double b) {return popops::checkTypes<>(a, b);} ); } -// popops::add(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsMulWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::mulWithOutput(a, b, c, d, e, f, g);} ); } +// popops::div(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsAdd", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::add(a, b, c, d, e, f);} ); } -// popops::addInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsDiv", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::div(a, b, c, d, e, f);} ); } +// popops::divInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsAddInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::addInPlace(a, b, c, d, e, f);} ); } -// popops::addWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsDivInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::divInPlace(a, b, c, d, e, f);} ); } +// popops::divWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsAddWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::addWithOutput(a, b, c, d, e, f, g);} ); } -// popops::atan2(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsDivWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::divWithOutput(a, b, c, d, e, f, g);} ); } +// popops::pow(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsAtan2", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::atan2(a, b, c, d, e, f);} ); } -// popops::atan2InPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsPow", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::pow(a, b, c, d, e, f);} ); } +// popops::powInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsAtan2InPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::atan2InPlace(a, b, c, d, e, f);} ); } -// popops::atan2WithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsPowInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::powInPlace(a, b, c, d, e, f);} ); } +// popops::powWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsAtan2WithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::atan2WithOutput(a, b, c, d, e, f, g);} ); } +mod.method("PopopsPowWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::powWithOutput(a, b, c, d, e, f, g);} ); } +// popops::rem(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsRem", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::rem(a, b, c, d, e, f);} ); } +// popops::remInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsRemInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::remInPlace(a, b, c, d, e, f);} ); } +// popops::remWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsRemWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::remWithOutput(a, b, c, d, e, f, g);} ); } // popops::bitwiseAnd(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; mod.method("PopopsBitwiseAnd", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::bitwiseAnd(a, b, c, d, e, f);} ); } @@ -3004,15 +3140,51 @@ mod.method("PopopsBitwiseXnorInPlace", [](poplar::Graph & a, const poplar::Tenso // popops::bitwiseXnorWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; mod.method("PopopsBitwiseXnorWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::bitwiseXnorWithOutput(a, b, c, d, e, f, g);} ); } -// popops::div(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +// popops::shiftLeft(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsDiv", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::div(a, b, c, d, e, f);} ); } -// popops::divInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsShiftLeft", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::shiftLeft(a, b, c, d, e, f);} ); } +// popops::shiftLeftInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsDivInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::divInPlace(a, b, c, d, e, f);} ); } -// popops::divWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsShiftLeftInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::shiftLeftInPlace(a, b, c, d, e, f);} ); } +// popops::shiftLeftWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsDivWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::divWithOutput(a, b, c, d, e, f, g);} ); } +mod.method("PopopsShiftLeftWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::shiftLeftWithOutput(a, b, c, d, e, f, g);} ); } +// popops::shiftRight(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsShiftRight", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::shiftRight(a, b, c, d, e, f);} ); } +// popops::shiftRightInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsShiftRightInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::shiftRightInPlace(a, b, c, d, e, f);} ); } +// popops::shiftRightWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsShiftRightWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::shiftRightWithOutput(a, b, c, d, e, f, g);} ); } +// popops::shiftRightSignExtend(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsShiftRightSignExtend", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::shiftRightSignExtend(a, b, c, d, e, f);} ); } +// popops::shiftRightSignExtendInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsShiftRightSignExtendInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::shiftRightSignExtendInPlace(a, b, c, d, e, f);} ); } +// popops::shiftRightSignExtendWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsShiftRightSignExtendWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::shiftRightSignExtendWithOutput(a, b, c, d, e, f, g);} ); } +// popops::logicalAnd(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLogicalAnd", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::logicalAnd(a, b, c, d, e, f);} ); } +// popops::logicalAndInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLogicalAndInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::logicalAndInPlace(a, b, c, d, e, f);} ); } +// popops::logicalAndWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLogicalAndWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::logicalAndWithOutput(a, b, c, d, e, f, g);} ); } +// popops::logicalOr(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLogicalOr", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::logicalOr(a, b, c, d, e, f);} ); } +// popops::logicalOrInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLogicalOrInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::logicalOrInPlace(a, b, c, d, e, f);} ); } +// popops::logicalOrWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsLogicalOrWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::logicalOrWithOutput(a, b, c, d, e, f, g);} ); } // popops::eq(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; mod.method("PopopsEq", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::eq(a, b, c, d, e, f);} ); } @@ -3022,6 +3194,15 @@ mod.method("PopopsEqInPlace", [](poplar::Graph & a, const poplar::Tensor & b, co // popops::eqWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; mod.method("PopopsEqWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::eqWithOutput(a, b, c, d, e, f, g);} ); } +// popops::neq(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsNeq", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::neq(a, b, c, d, e, f);} ); } +// popops::neqInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsNeqInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::neqInPlace(a, b, c, d, e, f);} ); } +// popops::neqWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +{ using namespace popops; +mod.method("PopopsNeqWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::neqWithOutput(a, b, c, d, e, f, g);} ); } // popops::gteq(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; mod.method("PopopsGteq", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::gteq(a, b, c, d, e, f);} ); } @@ -3040,15 +3221,6 @@ mod.method("PopopsGtInPlace", [](poplar::Graph & a, const poplar::Tensor & b, co // popops::gtWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; mod.method("PopopsGtWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::gtWithOutput(a, b, c, d, e, f, g);} ); } -// popops::invStdDevToVariance(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsInvStdDevToVariance", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::invStdDevToVariance(a, b, c, d, e, f);} ); } -// popops::invStdDevToVarianceInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsInvStdDevToVarianceInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::invStdDevToVarianceInPlace(a, b, c, d, e, f);} ); } -// popops::invStdDevToVarianceWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsInvStdDevToVarianceWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::invStdDevToVarianceWithOutput(a, b, c, d, e, f, g);} ); } // popops::lteq(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; mod.method("PopopsLteq", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::lteq(a, b, c, d, e, f);} ); } @@ -3058,24 +3230,6 @@ mod.method("PopopsLteqInPlace", [](poplar::Graph & a, const poplar::Tensor & b, // popops::lteqWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; mod.method("PopopsLteqWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::lteqWithOutput(a, b, c, d, e, f, g);} ); } -// popops::logicalAnd(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsLogicalAnd", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::logicalAnd(a, b, c, d, e, f);} ); } -// popops::logicalAndInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsLogicalAndInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::logicalAndInPlace(a, b, c, d, e, f);} ); } -// popops::logicalAndWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsLogicalAndWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::logicalAndWithOutput(a, b, c, d, e, f, g);} ); } -// popops::logicalOr(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsLogicalOr", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::logicalOr(a, b, c, d, e, f);} ); } -// popops::logicalOrInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsLogicalOrInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::logicalOrInPlace(a, b, c, d, e, f);} ); } -// popops::logicalOrWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsLogicalOrWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::logicalOrWithOutput(a, b, c, d, e, f, g);} ); } // popops::lt(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; mod.method("PopopsLt", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::lt(a, b, c, d, e, f);} ); } @@ -3103,78 +3257,24 @@ mod.method("PopopsMinInPlace", [](poplar::Graph & a, const poplar::Tensor & b, c // popops::minWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; mod.method("PopopsMinWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::minWithOutput(a, b, c, d, e, f, g);} ); } -// popops::mul(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsMul", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::mul(a, b, c, d, e, f);} ); } -// popops::mulInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsMulInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::mulInPlace(a, b, c, d, e, f);} ); } -// popops::mulWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsMulWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::mulWithOutput(a, b, c, d, e, f, g);} ); } -// popops::neq(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsNeq", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::neq(a, b, c, d, e, f);} ); } -// popops::neqInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsNeqInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::neqInPlace(a, b, c, d, e, f);} ); } -// popops::neqWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsNeqWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::neqWithOutput(a, b, c, d, e, f, g);} ); } -// popops::pow(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsPow", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::pow(a, b, c, d, e, f);} ); } -// popops::powInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsPowInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::powInPlace(a, b, c, d, e, f);} ); } -// popops::powWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsPowWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::powWithOutput(a, b, c, d, e, f, g);} ); } -// popops::rem(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsRem", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::rem(a, b, c, d, e, f);} ); } -// popops::remInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsRemInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::remInPlace(a, b, c, d, e, f);} ); } -// popops::remWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsRemWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::remWithOutput(a, b, c, d, e, f, g);} ); } -// popops::shiftLeft(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsShiftLeft", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::shiftLeft(a, b, c, d, e, f);} ); } -// popops::shiftLeftInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsShiftLeftInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::shiftLeftInPlace(a, b, c, d, e, f);} ); } -// popops::shiftLeftWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsShiftLeftWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::shiftLeftWithOutput(a, b, c, d, e, f, g);} ); } -// popops::shiftRight(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsShiftRight", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::shiftRight(a, b, c, d, e, f);} ); } -// popops::shiftRightInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsShiftRightInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::shiftRightInPlace(a, b, c, d, e, f);} ); } -// popops::shiftRightWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl -{ using namespace popops; -mod.method("PopopsShiftRightWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::shiftRightWithOutput(a, b, c, d, e, f, g);} ); } -// popops::shiftRightSignExtend(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +// popops::atan2(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsShiftRightSignExtend", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::shiftRightSignExtend(a, b, c, d, e, f);} ); } -// popops::shiftRightSignExtendInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsAtan2", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::atan2(a, b, c, d, e, f);} ); } +// popops::atan2InPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsShiftRightSignExtendInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::shiftRightSignExtendInPlace(a, b, c, d, e, f);} ); } -// popops::shiftRightSignExtendWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsAtan2InPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::atan2InPlace(a, b, c, d, e, f);} ); } +// popops::atan2WithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsShiftRightSignExtendWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::shiftRightSignExtendWithOutput(a, b, c, d, e, f, g);} ); } -// popops::sub(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsAtan2WithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::atan2WithOutput(a, b, c, d, e, f, g);} ); } +// popops::invStdDevToVariance(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsSub", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::sub(a, b, c, d, e, f);} ); } -// popops::subInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsInvStdDevToVariance", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::invStdDevToVariance(a, b, c, d, e, f);} ); } +// popops::invStdDevToVarianceInPlace(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsSubInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::subInPlace(a, b, c, d, e, f);} ); } -// popops::subWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl +mod.method("PopopsInvStdDevToVarianceInPlace", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::invStdDevToVarianceInPlace(a, b, c, d, e, f);} ); } +// popops::invStdDevToVarianceWithOutput(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; -mod.method("PopopsSubWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::subWithOutput(a, b, c, d, e, f, g);} ); } +mod.method("PopopsInvStdDevToVarianceWithOutput", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, const poplar::Tensor & d, poplar::program::Sequence & e, std::string f, const poplar::OptionFlags & g) {return popops::invStdDevToVarianceWithOutput(a, b, c, d, e, f, g);} ); } // popops::varianceToInvStdDev(poplar::Graph &, const poplar::Tensor &, const poplar::Tensor &, poplar::program::Sequence &, const poplar::DebugContext &, const poplar::OptionFlags &)__FunctionDecl { using namespace popops; mod.method("PopopsVarianceToInvStdDev", [](poplar::Graph & a, const poplar::Tensor & b, const poplar::Tensor & c, poplar::program::Sequence & d, std::string e, const poplar::OptionFlags & f) {return popops::varianceToInvStdDev(a, b, c, d, e, f);} ); } From f2bfc2a5957d594d2931dc6b50a1466b12d2b201 Mon Sep 17 00:00:00 2001 From: Gnimuc Date: Tue, 20 Aug 2024 23:26:08 +0900 Subject: [PATCH 5/6] debug --- deps/generate_wrapper.jl | 30 ++++++++++++++++++++---------- 1 file changed, 20 insertions(+), 10 deletions(-) diff --git a/deps/generate_wrapper.jl b/deps/generate_wrapper.jl index 430b794..51c1aa9 100644 --- a/deps/generate_wrapper.jl +++ b/deps/generate_wrapper.jl @@ -1,6 +1,7 @@ ## using Clang using Clang.LibClang +using Clang.Generators using JSON ## @@ -66,14 +67,14 @@ end function get_namespace(cursor::CLCursor) tmpcursor = cursor - while spelling(kind(tmpcursor)) != "Namespace" && Clang.getCursorLexicalParent(tmpcursor) != tmpcursor - tmpcursor = Clang.getCursorLexicalParent(tmpcursor) + while spelling(kind(tmpcursor)) != "Namespace" && Clang.getCursorSemanticParent(tmpcursor) != tmpcursor + tmpcursor = Clang.getCursorSemanticParent(tmpcursor) end if get_full_name(tmpcursor) == "" tmpcursor = Clang.clang_getCursorDefinition(cursor) - while spelling(kind(tmpcursor)) != "Namespace" && Clang.getCursorLexicalParent(tmpcursor) != tmpcursor - tmpcursor = Clang.getCursorLexicalParent(tmpcursor) + while spelling(kind(tmpcursor)) != "Namespace" && Clang.getCursorSemanticParent(tmpcursor) != tmpcursor + tmpcursor = Clang.getCursorSemanticParent(tmpcursor) end return get_full_name(tmpcursor) end @@ -83,8 +84,8 @@ end function get_class_name(cursor::CLCursor) tmpcursor = cursor - while spelling(kind(tmpcursor)) != "StructDecl" && spelling(kind(tmpcursor)) != "ClassDecl" && Clang.getCursorLexicalParent(tmpcursor) != tmpcursor - tmpcursor = Clang.getCursorLexicalParent(tmpcursor) + while spelling(kind(tmpcursor)) != "StructDecl" && spelling(kind(tmpcursor)) != "ClassDecl" && Clang.getCursorSemanticParent(tmpcursor) != tmpcursor + tmpcursor = Clang.getCursorSemanticParent(tmpcursor) end return get_full_name(tmpcursor) end @@ -188,7 +189,7 @@ end function arg_list(method::CLCursor, types=true::Bool, cutoff=Inf, varnames=true::Bool) Clang.getNumArguments(Clang.getCursorType(method)) == 0 && return "" cutoff == 0 && return "" - arglist = get_full_name(method) + arglist = get_full_name(method) # -> spelling(method) arglist = split(arglist, "(")[2] arglist = split(arglist, ")")[1] # TODO: this is **really** not a good way to do this @@ -419,7 +420,7 @@ function enum_const_handler(ctx::BindgenContext, decl::CLCursor)::Tuple{Union{No full_name = get_full_name(decl) julia_name = get_julia_name(decl) - parent_name = get_julia_name(Clang.getCursorLexicalParent(decl)) + parent_name = get_julia_name(Clang.getCursorSemanticParent(decl)) return "mod.set_const(\"$parent_name$julia_name\", $full_name);", nothing end @@ -606,7 +607,7 @@ function gen_bindings(headers::Vector{String}, blacklist::Vector{String}) println(io, "#include <$(header)>") end - includes = get_system_includes() + includes = [joinpath(@__DIR__, "wrapper", "3.3", "include")] ctx = DefaultBindgenContext() ctx.searched_headers = resolve_headers(headers, includes) ctx.blacklisted_headers = resolve_headers(blacklist, includes) @@ -618,7 +619,14 @@ function gen_bindings(headers::Vector{String}, blacklist::Vector{String}) tus = [] symbol_names = String[] # add compiler flags - clang_args = ["-I"*inc for inc in includes] + # clang_args = ["-I"*inc for inc in includes] + # cross-compiling setup for DEBUG: + args = get_default_args("x86_64-linux-gnu", is_cxx=true, version=v"9.1.0") + append!(args, ["-I"*inc for inc in includes]) + push!(args, "-nostdinc++", "-nostdlib++") + push!(args, "-xc++") + # push!(args, "-v") + clang_args = args for h in ctx.searched_headers tu = Clang.TranslationUnit(idx, h, clang_args, flags) push!(tus, tu) @@ -659,3 +667,5 @@ function generate_wrapper() return nothing end + +generate_wrapper() From 4eb3b9aa1efa52fa69475572cbe05e81575e9ff4 Mon Sep 17 00:00:00 2001 From: Gnimuc Date: Tue, 20 Aug 2024 23:49:43 +0900 Subject: [PATCH 6/6] hacks --- deps/generate_wrapper.jl | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/deps/generate_wrapper.jl b/deps/generate_wrapper.jl index 51c1aa9..ae4310b 100644 --- a/deps/generate_wrapper.jl +++ b/deps/generate_wrapper.jl @@ -231,6 +231,10 @@ function arg_list(method::CLCursor, types=true::Bool, cutoff=Inf, varnames=true: item = replace(item, "poplar::DebugContext" => "std::string") item = replace(item, "poplar::StringRef" => "std::string") + # item = replace(item, "const DebugContext &" => "std::string") + # item = replace(item, "DebugContext" => "std::string") + # item = replace(item, "StringRef" => "std::string") + if types pre = "" if should_wrap(item) @@ -467,6 +471,7 @@ function iterate_children(ctx::BindgenContext, childvec::Vector{CLCursor}) child_id = get_full_name(child) * "__" * spelling(child_kind) child_id = replace(child_id, "poplar::StringRef" => "std::string") + # child_id = replace(child_id, "StringRef" => "std::string") # prevents duplicate codegen(+error), TODO: check if still necessary child_id == "poplar::FieldData::SizeT::size()__CXXMethod" && (valid = false; reason = "filedata_size_blacklist") @@ -492,9 +497,11 @@ function iterate_children(ctx::BindgenContext, childvec::Vector{CLCursor}) # This conversion `ArrayRef` to `ArrayRef` isn't handled correctly contains(child_id, "poplar::Graph::trace(ArrayRef") && (valid = false; reason = "arrayrefstring_blacklisted") + # contains(child_id, "trace(ArrayRef") && (valid = false; reason = "arrayrefstring_blacklisted") # `DebugContext` constructors which cause ambiguous overload calls contains(child_id, r"^poplar::DebugContext::DebugContext.*__CXXConstructor$") && (valid = false; reason = "debugcontext_blacklisted") + # contains(child_id, r"^DebugContext.*__CXXConstructor$") && (valid = false; reason = "debugcontext_blacklisted") # This causes the error # no matching function for call to ‘poplar::program::Sequence::add_many(std::__cxx11::basic_string&)’ @@ -502,6 +509,7 @@ function iterate_children(ctx::BindgenContext, childvec::Vector{CLCursor}) # Avoid duplicate definition during precompilation of the CxxWrap module contains(child_id, "poplar::layout::to_string(const poplar::layout::VectorList)__FunctionDecl") && (valid = false; reason = "duplicate_definition") + # contains(child_id, "poplar::layout::to_string(const VectorList)__FunctionDecl") && (valid = false; reason = "duplicate_definition") # Avoid duplicate definition during precompilation of the CxxWrap module. # Ref: . @@ -509,12 +517,15 @@ function iterate_children(ctx::BindgenContext, childvec::Vector{CLCursor}) # error: invalid use of incomplete type ‘class pva::Report’ contains(child_id, "poplar::Engine::getReport") && (valid = false; reason = "incomplete_type") + # contains(child_id, "Engine::getReport") && (valid = false; reason = "incomplete_type") # error: invalid application of ‘sizeof’ to incomplete type ‘poplar::core::VertexIntrospector’ contains(child_id, "poplar::VertexIntrospector") && (valid = false; reason = "incomplete_type") + # contains(child_id, "VertexIntrospector") && (valid = false; reason = "incomplete_type") # error: invalid use of incomplete type ‘class poplar::Preallocations’ contains(child_id, "poplar::Preallocations") && (valid = false; reason = "incomplete_type") + # contains(child_id, "Preallocations") && (valid = false; reason = "incomplete_type") # error: no matching function for call to ‘poplar::GlobalExchangeConstraint::GlobalExchangeConstraint()’ contains(child_id, "poplar::Target::getGlobalExchangeConstraints()__CXXMethod") && (valid = false; reason = "getGlobalExchangeConstraints_blacklisted")