Skip to content

GitLab

Commit eea003a5 authored by Paul's avatar Paul
Browse files

s/rtg/migraph

parent 5f1ea74f
Hide whitespace changes
Inline Side-by-side
Showing with 360 additions and 360 deletions
src/targets/cpu/CMakeLists.txt
View file @ eea003a5
add_library(rtg_cpu add_library(migraph_cpu
cpu_target.cpp cpu_target.cpp
) )
rocm_clang_tidy_check(rtg_cpu) rocm_clang_tidy_check(migraph_cpu)
target_link_libraries(rtg_cpu rtg) target_link_libraries(migraph_cpu migraph)
target_include_directories(rtg_cpu PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>) target_include_directories(migraph_cpu PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>)
src/targets/cpu/cpu_target.cpp
View file @ eea003a5
#include <rtg/cpu/cpu_target.hpp> #include <migraph/cpu/cpu_target.hpp>
#include <rtg/instruction.hpp> #include <migraph/instruction.hpp>
#include <rtg/dfor.hpp> #include <migraph/dfor.hpp>
#include <rtg/operators.hpp> #include <migraph/operators.hpp>
#include <rtg/shape_for_each.hpp> #include <migraph/shape_for_each.hpp>
namespace rtg { namespace migraph {
namespace cpu { namespace cpu {
template <typename T> template <typename T>
...@@ -544,4 +544,4 @@ void cpu_target::apply(program& p) const { cpu_apply{&p}.apply(); } ...@@ -544,4 +544,4 @@ void cpu_target::apply(program& p) const { cpu_apply{&p}.apply(); }
} // namespace cpu } // namespace cpu
} // namespace rtg } // namespace migraph
src/targets/cpu/include/rtg/cpu/cpu_target.hpp → src/targets/cpu/include/migraph/cpu/cpu_target.hpp
View file @ eea003a5
#ifndef RTG_GUARD_RTGLIB_CPU_TARGET_HPP #ifndef MIGRAPH_GUARD_MIGRAPHLIB_CPU_TARGET_HPP
#define RTG_GUARD_RTGLIB_CPU_TARGET_HPP #define MIGRAPH_GUARD_MIGRAPHLIB_CPU_TARGET_HPP
#include <rtg/program.hpp> #include <migraph/program.hpp>
namespace rtg { namespace migraph {
namespace cpu { namespace cpu {
struct cpu_target struct cpu_target
...@@ -15,6 +15,6 @@ struct cpu_target ...@@ -15,6 +15,6 @@ struct cpu_target
} // namespace cpu } // namespace cpu
} // namespace rtg } // namespace migraph
#endif #endif
src/targets/miopen/CMakeLists.txt
View file @ eea003a5
...@@ -6,10 +6,10 @@ if(NOT TARGET MIOpen) ...@@ -6,10 +6,10 @@ if(NOT TARGET MIOpen)
message(SEND_ERROR "Cant find miopen") message(SEND_ERROR "Cant find miopen")
endif() endif()
add_library(rtg_miopen add_library(migraph_miopen
hip.cpp hip.cpp
miopen_target.cpp miopen_target.cpp
) )
rocm_clang_tidy_check(rtg_miopen) rocm_clang_tidy_check(migraph_miopen)
target_link_libraries(rtg_miopen rtg MIOpen) target_link_libraries(migraph_miopen migraph MIOpen)
target_include_directories(rtg_miopen PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>) target_include_directories(migraph_miopen PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>)
src/targets/miopen/hip.cpp
View file @ eea003a5
#include <rtg/miopen/hip.hpp> #include <migraph/miopen/hip.hpp>
#include <rtg/manage_ptr.hpp> #include <migraph/manage_ptr.hpp>
#include <miopen/miopen.h> #include <miopen/miopen.h>
#include <vector> #include <vector>
namespace rtg { namespace migraph {
namespace miopen { namespace miopen {
using hip_ptr = RTG_MANAGE_PTR(void, hipFree); using hip_ptr = MIGRAPH_MANAGE_PTR(void, hipFree);
hip_ptr allocate_gpu(std::size_t sz) hip_ptr allocate_gpu(std::size_t sz)
{ {
...@@ -44,21 +44,21 @@ hip_ptr write_to_gpu(const void* x, std::size_t sz) ...@@ -44,21 +44,21 @@ hip_ptr write_to_gpu(const void* x, std::size_t sz)
return result; return result;
} }
rtg::argument allocate_gpu(rtg::shape s) migraph::argument allocate_gpu(migraph::shape s)
{ {
auto p = share(allocate_gpu(s.bytes())); auto p = share(allocate_gpu(s.bytes()));
return {s, [p]() mutable { return reinterpret_cast<char*>(p.get()); }}; return {s, [p]() mutable { return reinterpret_cast<char*>(p.get()); }};
} }
rtg::argument to_gpu(rtg::argument arg) migraph::argument to_gpu(migraph::argument arg)
{ {
auto p = share(write_to_gpu(arg.data(), arg.get_shape().bytes())); auto p = share(write_to_gpu(arg.data(), arg.get_shape().bytes()));
return {arg.get_shape(), [p]() mutable { return reinterpret_cast<char*>(p.get()); }}; return {arg.get_shape(), [p]() mutable { return reinterpret_cast<char*>(p.get()); }};
} }
rtg::argument from_gpu(rtg::argument arg) migraph::argument from_gpu(migraph::argument arg)
{ {
rtg::argument result; migraph::argument result;
arg.visit([&](auto x) { arg.visit([&](auto x) {
using type = typename decltype(x)::value_type; using type = typename decltype(x)::value_type;
auto v = read_from_gpu<type>(arg.data(), x.get_shape().bytes() / sizeof(type)); auto v = read_from_gpu<type>(arg.data(), x.get_shape().bytes() / sizeof(type));
...@@ -69,4 +69,4 @@ rtg::argument from_gpu(rtg::argument arg) ...@@ -69,4 +69,4 @@ rtg::argument from_gpu(rtg::argument arg)
} // namespace miopen } // namespace miopen
} // namespace rtg } // namespace migraph
src/targets/miopen/include/rtg/miopen/hip.hpp → src/targets/miopen/include/migraph/miopen/hip.hpp
View file @ eea003a5
#ifndef RTG_GUARD_RTGLIB_HIP_HPP #ifndef MIGRAPH_GUARD_MIGRAPHLIB_HIP_HPP
#define RTG_GUARD_RTGLIB_HIP_HPP #define MIGRAPH_GUARD_MIGRAPHLIB_HIP_HPP
#include <rtg/operators.hpp> #include <migraph/operators.hpp>
namespace rtg { namespace migraph {
namespace miopen { namespace miopen {
rtg::argument allocate_gpu(rtg::shape s); migraph::argument allocate_gpu(migraph::shape s);
rtg::argument to_gpu(rtg::argument arg); migraph::argument to_gpu(migraph::argument arg);
rtg::argument from_gpu(rtg::argument arg); migraph::argument from_gpu(migraph::argument arg);
struct hip_allocate struct hip_allocate
{ {
...@@ -28,6 +28,6 @@ struct hip_allocate ...@@ -28,6 +28,6 @@ struct hip_allocate
} // namespace miopen } // namespace miopen
} // namespace rtg } // namespace migraph
#endif #endif
src/targets/miopen/include/rtg/miopen/miopen.hpp → src/targets/miopen/include/migraph/miopen/miopen.hpp
View file @ eea003a5
#ifndef RTG_GUARD_RTGLIB_MIOPEN_HPP #ifndef MIGRAPH_GUARD_MIGRAPHLIB_MIOPEN_HPP
#define RTG_GUARD_RTGLIB_MIOPEN_HPP #define MIGRAPH_GUARD_MIGRAPHLIB_MIOPEN_HPP
#include <rtg/manage_ptr.hpp> #include <migraph/manage_ptr.hpp>
#include <miopen/miopen.h> #include <miopen/miopen.h>
namespace rtg { namespace migraph {
namespace miopen { namespace miopen {
using miopen_handle = RTG_MANAGE_PTR(miopenHandle_t, miopenDestroy); using miopen_handle = MIGRAPH_MANAGE_PTR(miopenHandle_t, miopenDestroy);
using tensor_descriptor = RTG_MANAGE_PTR(miopenTensorDescriptor_t, miopenDestroyTensorDescriptor); using tensor_descriptor = MIGRAPH_MANAGE_PTR(miopenTensorDescriptor_t, miopenDestroyTensorDescriptor);
using convolution_descriptor = RTG_MANAGE_PTR(miopenConvolutionDescriptor_t, using convolution_descriptor = MIGRAPH_MANAGE_PTR(miopenConvolutionDescriptor_t,
miopenDestroyConvolutionDescriptor); miopenDestroyConvolutionDescriptor);
using pooling_descriptor = RTG_MANAGE_PTR(miopenPoolingDescriptor_t, using pooling_descriptor = MIGRAPH_MANAGE_PTR(miopenPoolingDescriptor_t,
miopenDestroyPoolingDescriptor); miopenDestroyPoolingDescriptor);
using activation_descriptor = RTG_MANAGE_PTR(miopenActivationDescriptor_t, using activation_descriptor = MIGRAPH_MANAGE_PTR(miopenActivationDescriptor_t,
miopenDestroyActivationDescriptor); miopenDestroyActivationDescriptor);
template <class Result, class F, class... Ts> template <class Result, class F, class... Ts>
...@@ -24,11 +24,11 @@ Result make_obj(F f, Ts... xs) ...@@ -24,11 +24,11 @@ Result make_obj(F f, Ts... xs)
auto status = f(&x, xs...); auto status = f(&x, xs...);
Result r{x}; Result r{x};
if(status != miopenStatusSuccess) if(status != miopenStatusSuccess)
RTG_THROW("MIOpen call failed"); MIGRAPH_THROW("MIOpen call failed");
return r; return r;
} }
inline tensor_descriptor make_tensor(const rtg::shape& s) inline tensor_descriptor make_tensor(const migraph::shape& s)
{ {
auto t = make_obj<tensor_descriptor>(&miopenCreateTensorDescriptor); auto t = make_obj<tensor_descriptor>(&miopenCreateTensorDescriptor);
// Convert to ints // Convert to ints
...@@ -38,12 +38,12 @@ inline tensor_descriptor make_tensor(const rtg::shape& s) ...@@ -38,12 +38,12 @@ inline tensor_descriptor make_tensor(const rtg::shape& s)
if(s.type() == shape::float_type) if(s.type() == shape::float_type)
d = miopenFloat; d = miopenFloat;
else else
RTG_THROW("Unsupported type"); MIGRAPH_THROW("Unsupported type");
miopenSetTensorDescriptor(t.get(), d, s.lens().size(), lens.data(), strides.data()); miopenSetTensorDescriptor(t.get(), d, s.lens().size(), lens.data(), strides.data());
return t; return t;
} }
inline convolution_descriptor make_conv(const rtg::convolution& op) inline convolution_descriptor make_conv(const migraph::convolution& op)
{ {
auto c = make_obj<convolution_descriptor>(&miopenCreateConvolutionDescriptor); auto c = make_obj<convolution_descriptor>(&miopenCreateConvolutionDescriptor);
miopenInitConvolutionDescriptor(c.get(), miopenInitConvolutionDescriptor(c.get(),
...@@ -57,7 +57,7 @@ inline convolution_descriptor make_conv(const rtg::convolution& op) ...@@ -57,7 +57,7 @@ inline convolution_descriptor make_conv(const rtg::convolution& op)
return c; return c;
} }
inline pooling_descriptor make_pooling(const rtg::pooling& op) inline pooling_descriptor make_pooling(const migraph::pooling& op)
{ {
miopenPoolingMode_t mode; miopenPoolingMode_t mode;
if(op.mode == "max") if(op.mode == "max")
...@@ -85,6 +85,6 @@ inline activation_descriptor make_relu() ...@@ -85,6 +85,6 @@ inline activation_descriptor make_relu()
} // namespace miopen } // namespace miopen
} // namespace rtg } // namespace migraph
#endif #endif
src/targets/miopen/include/rtg/miopen/miopen_target.hpp → src/targets/miopen/include/migraph/miopen/miopen_target.hpp
View file @ eea003a5
#ifndef RTG_GUARD_RTGLIB_MIOPEN_TARGET_HPP #ifndef MIGRAPH_GUARD_MIGRAPHLIB_MIOPEN_TARGET_HPP
#define RTG_GUARD_RTGLIB_MIOPEN_TARGET_HPP #define MIGRAPH_GUARD_MIGRAPHLIB_MIOPEN_TARGET_HPP
#include <rtg/program.hpp> #include <migraph/program.hpp>
namespace rtg { namespace migraph {
namespace miopen { namespace miopen {
struct miopen_target struct miopen_target
...@@ -15,6 +15,6 @@ struct miopen_target ...@@ -15,6 +15,6 @@ struct miopen_target
} // namespace miopen } // namespace miopen
} // namespace rtg } // namespace migraph
#endif #endif
src/targets/miopen/miopen_target.cpp
View file @ eea003a5
#include <rtg/miopen/miopen_target.hpp> #include <migraph/miopen/miopen_target.hpp>
#include <rtg/manage_ptr.hpp> #include <migraph/manage_ptr.hpp>
#include <rtg/instruction.hpp> #include <migraph/instruction.hpp>
#include <rtg/operators.hpp> #include <migraph/operators.hpp>
#include <rtg/shape_for_each.hpp> #include <migraph/shape_for_each.hpp>
#include <rtg/miopen/miopen.hpp> #include <migraph/miopen/miopen.hpp>
#include <rtg/miopen/hip.hpp> #include <migraph/miopen/hip.hpp>
#include <rtg/dfor.hpp> #include <migraph/dfor.hpp>
namespace rtg { namespace migraph {
namespace miopen { namespace miopen {
struct miopen_context struct miopen_context
...@@ -310,4 +310,4 @@ context miopen_target::get_context() const ...@@ -310,4 +310,4 @@ context miopen_target::get_context() const
} // namespace miopen } // namespace miopen
} // namespace rtg } // namespace migraph
test/CMakeLists.txt
View file @ eea003a5
...@@ -10,12 +10,12 @@ set(CTEST_PARALLEL_LEVEL ${N} CACHE STRING "CTest parallel level") ...@@ -10,12 +10,12 @@ set(CTEST_PARALLEL_LEVEL ${N} CACHE STRING "CTest parallel level")
add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -j ${CTEST_PARALLEL_LEVEL} -C ${CMAKE_CFG_INTDIR}) add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -j ${CTEST_PARALLEL_LEVEL} -C ${CMAKE_CFG_INTDIR})
add_custom_target(tests) add_custom_target(tests)
find_program(RTG_GDB gdb) find_program(MIGRAPH_GDB gdb)
if(RTG_GDB) if(MIGRAPH_GDB)
set(RTG_TEST_GDB On CACHE BOOL "") set(MIGRAPH_TEST_GDB On CACHE BOOL "")
else() else()
set(RTG_TEST_GDB Off CACHE BOOL "") set(MIGRAPH_TEST_GDB Off CACHE BOOL "")
endif() endif()
set(SKIP_TESTS) set(SKIP_TESTS)
...@@ -34,8 +34,8 @@ function(add_test_command NAME EXE) ...@@ -34,8 +34,8 @@ function(add_test_command NAME EXE)
%1 ${ARGN}") %1 ${ARGN}")
add_test(NAME ${NAME} COMMAND ${WINE_CMD} cmd /c "${CMAKE_CURRENT_BINARY_DIR}/test_${NAME}.cmd" $<TARGET_FILE:${EXE}>) add_test(NAME ${NAME} COMMAND ${WINE_CMD} cmd /c "${CMAKE_CURRENT_BINARY_DIR}/test_${NAME}.cmd" $<TARGET_FILE:${EXE}>)
else() else()
if(RTG_TEST_GDB) if(MIGRAPH_TEST_GDB)
# add_test(NAME ${NAME} COMMAND ${RTG_GDB} # add_test(NAME ${NAME} COMMAND ${MIGRAPH_GDB}
# --batch # --batch
# --return-child-result # --return-child-result
# -ex "set disable-randomization off" # -ex "set disable-randomization off"
...@@ -52,7 +52,7 @@ function(add_test_command NAME EXE) ...@@ -52,7 +52,7 @@ function(add_test_command NAME EXE)
if(NOT RESULT EQUAL 0) if(NOT RESULT EQUAL 0)
# TODO: check for core files based on pid when setting /proc/sys/kernel/core_uses_pid # TODO: check for core files based on pid when setting /proc/sys/kernel/core_uses_pid
if(EXISTS ${TEST_DIR}/core) if(EXISTS ${TEST_DIR}/core)
execute_process(COMMAND ${RTG_GDB} $<TARGET_FILE:${EXE}> ${TEST_DIR}/core -batch -ex bt) execute_process(COMMAND ${MIGRAPH_GDB} $<TARGET_FILE:${EXE}> ${TEST_DIR}/core -batch -ex bt)
endif() endif()
message(FATAL_ERROR \"Test failed\") message(FATAL_ERROR \"Test failed\")
endif() endif()
...@@ -82,7 +82,7 @@ function(add_test_executable TEST_NAME) ...@@ -82,7 +82,7 @@ function(add_test_executable TEST_NAME)
add_dependencies(tests ${TEST_NAME}) add_dependencies(tests ${TEST_NAME})
add_dependencies(check ${TEST_NAME}) add_dependencies(check ${TEST_NAME})
set_tests_properties(${TEST_NAME} PROPERTIES FAIL_REGULAR_EXPRESSION "FAILED") set_tests_properties(${TEST_NAME} PROPERTIES FAIL_REGULAR_EXPRESSION "FAILED")
target_link_libraries(${TEST_NAME} rtg rtg_cpu) target_link_libraries(${TEST_NAME} migraph migraph_cpu)
target_include_directories(${TEST_NAME} PUBLIC include) target_include_directories(${TEST_NAME} PUBLIC include)
endfunction(add_test_executable) endfunction(add_test_executable)
...@@ -93,13 +93,13 @@ foreach(TEST ${TESTS}) ...@@ -93,13 +93,13 @@ foreach(TEST ${TESTS})
add_test_executable(test_${BASE_NAME} ${TEST}) add_test_executable(test_${BASE_NAME} ${TEST})
endforeach() endforeach()
if(RTG_ENABLE_MIOPEN) if(MIGRAPH_ENABLE_MIOPEN)
# miopen tests # miopen tests
file(GLOB MIOPEN_TESTS miopen/*.cpp) file(GLOB MIOPEN_TESTS miopen/*.cpp)
foreach(TEST ${MIOPEN_TESTS}) foreach(TEST ${MIOPEN_TESTS})
get_filename_component(BASE_NAME ${TEST} NAME_WE) get_filename_component(BASE_NAME ${TEST} NAME_WE)
add_test_executable(test_miopen_${BASE_NAME} ${TEST}) add_test_executable(test_miopen_${BASE_NAME} ${TEST})
target_link_libraries(test_miopen_${BASE_NAME} rtg_miopen) target_link_libraries(test_miopen_${BASE_NAME} migraph_miopen)
endforeach() endforeach()
endif() endif()
test/cpu_ops_test.cpp
View file @ eea003a5
#include <iostream> #include <iostream>
#include <vector> #include <vector>
#include <rtg/literal.hpp> #include <migraph/literal.hpp>
#include <rtg/operators.hpp> #include <migraph/operators.hpp>
#include <rtg/cpu/cpu_target.hpp> #include <migraph/cpu/cpu_target.hpp>
#include "test.hpp" #include "test.hpp"
#include "verify.hpp" #include "verify.hpp"
void exp_test() void exp_test()
{ {
rtg::program p; migraph::program p;
rtg::shape s{rtg::shape::float_type, {3}}; migraph::shape s{migraph::shape::float_type, {3}};
auto l = p.add_literal(rtg::literal{s, {-1, 0, 1}}); auto l = p.add_literal(migraph::literal{s, {-1, 0, 1}});
p.add_instruction(rtg::exp{}, l); p.add_instruction(migraph::exp{}, l);
p.compile(rtg::cpu::cpu_target{}); p.compile(migraph::cpu::cpu_target{});
auto result = p.eval({}); auto result = p.eval({});
std::vector<float> results_vector(3); std::vector<float> results_vector(3);
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); }); result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
...@@ -22,11 +22,11 @@ void exp_test() ...@@ -22,11 +22,11 @@ void exp_test()
void sin_test() void sin_test()
{ {
rtg::program p; migraph::program p;
rtg::shape s{rtg::shape::float_type, {3}}; migraph::shape s{migraph::shape::float_type, {3}};
auto l = p.add_literal(rtg::literal{s, {-1, 0, 1}}); auto l = p.add_literal(migraph::literal{s, {-1, 0, 1}});
p.add_instruction(rtg::sin{}, l); p.add_instruction(migraph::sin{}, l);
p.compile(rtg::cpu::cpu_target{}); p.compile(migraph::cpu::cpu_target{});
auto result = p.eval({}); auto result = p.eval({});
std::vector<float> results_vector(3); std::vector<float> results_vector(3);
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); }); result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
...@@ -36,11 +36,11 @@ void sin_test() ...@@ -36,11 +36,11 @@ void sin_test()
void cos_test() void cos_test()
{ {
rtg::program p; migraph::program p;
rtg::shape s{rtg::shape::float_type, {3}}; migraph::shape s{migraph::shape::float_type, {3}};
auto l = p.add_literal(rtg::literal{s, {-1, 0, 1}}); auto l = p.add_literal(migraph::literal{s, {-1, 0, 1}});
p.add_instruction(rtg::cos{}, l); p.add_instruction(migraph::cos{}, l);
p.compile(rtg::cpu::cpu_target{}); p.compile(migraph::cpu::cpu_target{});
auto result = p.eval({}); auto result = p.eval({});
std::vector<float> results_vector(3); std::vector<float> results_vector(3);
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); }); result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
...@@ -50,11 +50,11 @@ void cos_test() ...@@ -50,11 +50,11 @@ void cos_test()
void tan_test() void tan_test()
{ {
rtg::program p; migraph::program p;
rtg::shape s{rtg::shape::float_type, {3}}; migraph::shape s{migraph::shape::float_type, {3}};
auto l = p.add_literal(rtg::literal{s, {-1, 0, 1}}); auto l = p.add_literal(migraph::literal{s, {-1, 0, 1}});
p.add_instruction(rtg::tan{}, l); p.add_instruction(migraph::tan{}, l);
p.compile(rtg::cpu::cpu_target{}); p.compile(migraph::cpu::cpu_target{});
auto result = p.eval({}); auto result = p.eval({});
std::vector<float> results_vector(3); std::vector<float> results_vector(3);
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); }); result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
...@@ -64,12 +64,12 @@ void tan_test() ...@@ -64,12 +64,12 @@ void tan_test()
void add_test() void add_test()
{ {
rtg::program p; migraph::program p;
rtg::shape s{rtg::shape::float_type, {3}}; migraph::shape s{migraph::shape::float_type, {3}};
auto l1 = p.add_literal(rtg::literal{s, {-1, 0, 1}}); auto l1 = p.add_literal(migraph::literal{s, {-1, 0, 1}});
auto l2 = p.add_literal(rtg::literal{s, {1, 2, 3}}); auto l2 = p.add_literal(migraph::literal{s, {1, 2, 3}});
p.add_instruction(rtg::add{}, l1, l2); p.add_instruction(migraph::add{}, l1, l2);
p.compile(rtg::cpu::cpu_target{}); p.compile(migraph::cpu::cpu_target{});
auto result = p.eval({}); auto result = p.eval({});
std::vector<float> results_vector(3); std::vector<float> results_vector(3);
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); }); result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
...@@ -79,16 +79,16 @@ void add_test() ...@@ -79,16 +79,16 @@ void add_test()
void broadcast_test() void broadcast_test()
{ {
rtg::program p; migraph::program p;
rtg::shape a_shape{rtg::shape::int32_type, {2, 2}}; migraph::shape a_shape{migraph::shape::int32_type, {2, 2}};
std::vector<int32_t> a_data{0, 0, 0, 0}; std::vector<int32_t> a_data{0, 0, 0, 0};
rtg::shape b_shape{rtg::shape::int32_type, {2}}; migraph::shape b_shape{migraph::shape::int32_type, {2}};
std::vector<int32_t> b_data{-2, -3}; std::vector<int32_t> b_data{-2, -3};
uint64_t axis = 0; uint64_t axis = 0;
auto l1 = p.add_literal(rtg::literal{a_shape, a_data}); auto l1 = p.add_literal(migraph::literal{a_shape, a_data});
auto l2 = p.add_literal(rtg::literal{b_shape, b_data}); auto l2 = p.add_literal(migraph::literal{b_shape, b_data});
p.add_instruction(rtg::broadcast{axis}, l1, l2); p.add_instruction(migraph::broadcast{axis}, l1, l2);
p.compile(rtg::cpu::cpu_target{}); p.compile(migraph::cpu::cpu_target{});
auto result = p.eval({}); auto result = p.eval({});
auto output = result.get<int32_t>(); auto output = result.get<int32_t>();
EXPECT(output(0, 0) == -2); EXPECT(output(0, 0) == -2);
...@@ -98,17 +98,17 @@ void broadcast_test() ...@@ -98,17 +98,17 @@ void broadcast_test()
} }
void add_broadcast_test() void add_broadcast_test()
{ {
rtg::program p; migraph::program p;
rtg::shape a_shape{rtg::shape::float_type, {2, 2, 3}}; migraph::shape a_shape{migraph::shape::float_type, {2, 2, 3}};
std::vector<float> a_data{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}; std::vector<float> a_data{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
rtg::shape b_shape{rtg::shape::float_type, {2, 2}}; migraph::shape b_shape{migraph::shape::float_type, {2, 2}};
std::vector<float> b_data{0, -1, -2, -3}; std::vector<float> b_data{0, -1, -2, -3};
uint64_t axis = 0; uint64_t axis = 0;
auto l1 = p.add_literal(rtg::literal{a_shape, a_data}); auto l1 = p.add_literal(migraph::literal{a_shape, a_data});
auto l2 = p.add_literal(rtg::literal{b_shape, b_data}); auto l2 = p.add_literal(migraph::literal{b_shape, b_data});
auto l3 = p.add_instruction(rtg::broadcast{axis}, l1, l2); auto l3 = p.add_instruction(migraph::broadcast{axis}, l1, l2);
p.add_instruction(rtg::add{}, l1, l3); p.add_instruction(migraph::add{}, l1, l3);
p.compile(rtg::cpu::cpu_target{}); p.compile(migraph::cpu::cpu_target{});
auto result = p.eval({}); auto result = p.eval({});
EXPECT(result.get_shape().packed()); EXPECT(result.get_shape().packed());
std::vector<float> results_vector(12); std::vector<float> results_vector(12);
...@@ -119,12 +119,12 @@ void add_broadcast_test() ...@@ -119,12 +119,12 @@ void add_broadcast_test()
void sub_test() void sub_test()
{ {
rtg::program p; migraph::program p;
rtg::shape s{rtg::shape::float_type, {3}}; migraph::shape s{migraph::shape::float_type, {3}};
auto l1 = p.add_literal(rtg::literal{s, {-1, 0, 1}}); auto l1 = p.add_literal(migraph::literal{s, {-1, 0, 1}});
auto l2 = p.add_literal(rtg::literal{s, {1, 2, 3}}); auto l2 = p.add_literal(migraph::literal{s, {1, 2, 3}});
p.add_instruction(rtg::sub{}, l1, l2); p.add_instruction(migraph::sub{}, l1, l2);
p.compile(rtg::cpu::cpu_target{}); p.compile(migraph::cpu::cpu_target{});
auto result = p.eval({}); auto result = p.eval({});
std::vector<float> results_vector(3); std::vector<float> results_vector(3);
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); }); result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
...@@ -134,12 +134,12 @@ void sub_test() ...@@ -134,12 +134,12 @@ void sub_test()
void mul_test() void mul_test()
{ {
rtg::program p; migraph::program p;
rtg::shape s{rtg::shape::float_type, {3}}; migraph::shape s{migraph::shape::float_type, {3}};
auto l1 = p.add_literal(rtg::literal{s, {-1, 0, 1}}); auto l1 = p.add_literal(migraph::literal{s, {-1, 0, 1}});
auto l2 = p.add_literal(rtg::literal{s, {1, 2, 3}}); auto l2 = p.add_literal(migraph::literal{s, {1, 2, 3}});
p.add_instruction(rtg::mul{}, l1, l2); p.add_instruction(migraph::mul{}, l1, l2);
p.compile(rtg::cpu::cpu_target{}); p.compile(migraph::cpu::cpu_target{});
auto result = p.eval({}); auto result = p.eval({});
std::vector<float> results_vector(3); std::vector<float> results_vector(3);
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); }); result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
...@@ -149,12 +149,12 @@ void mul_test() ...@@ -149,12 +149,12 @@ void mul_test()
void div_test() void div_test()
{ {
rtg::program p; migraph::program p;
rtg::shape s{rtg::shape::float_type, {3}}; migraph::shape s{migraph::shape::float_type, {3}};
auto l1 = p.add_literal(rtg::literal{s, {-1.0f, 0.5f, 1.0f}}); auto l1 = p.add_literal(migraph::literal{s, {-1.0f, 0.5f, 1.0f}});
auto l2 = p.add_literal(rtg::literal{s, {1.0f, 2.0f, 4.0f}}); auto l2 = p.add_literal(migraph::literal{s, {1.0f, 2.0f, 4.0f}});
p.add_instruction(rtg::div{}, l1, l2); p.add_instruction(migraph::div{}, l1, l2);
p.compile(rtg::cpu::cpu_target{}); p.compile(migraph::cpu::cpu_target{});
auto result = p.eval({}); auto result = p.eval({});
std::vector<float> results_vector(3); std::vector<float> results_vector(3);
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); }); result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
...@@ -164,37 +164,37 @@ void div_test() ...@@ -164,37 +164,37 @@ void div_test()
void reshape_test() void reshape_test()
{ {
rtg::shape a_shape{rtg::shape::float_type, {24, 1, 1, 1}}; migraph::shape a_shape{migraph::shape::float_type, {24, 1, 1, 1}};
std::vector<float> data(24); std::vector<float> data(24);
std::iota(data.begin(), data.end(), -3); std::iota(data.begin(), data.end(), -3);
{ {
rtg::program p; migraph::program p;
auto l = p.add_literal(rtg::literal{a_shape, data}); auto l = p.add_literal(migraph::literal{a_shape, data});
std::vector<int64_t> new_shape = {8, 3, 1, 1}; std::vector<int64_t> new_shape = {8, 3, 1, 1};
p.add_instruction(rtg::reshape{new_shape}, l); p.add_instruction(migraph::reshape{new_shape}, l);
p.compile(rtg::cpu::cpu_target{}); p.compile(migraph::cpu::cpu_target{});
auto result = p.eval({}); auto result = p.eval({});
std::vector<float> results_vector(3); std::vector<float> results_vector(3);
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); }); result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
EXPECT(test::verify_range(results_vector, data)); EXPECT(test::verify_range(results_vector, data));
} }
{ {
rtg::program p; migraph::program p;
auto l = p.add_literal(rtg::literal{a_shape, data}); auto l = p.add_literal(migraph::literal{a_shape, data});
std::vector<int64_t> new_shape = {1, 3, 4, 2}; std::vector<int64_t> new_shape = {1, 3, 4, 2};
p.add_instruction(rtg::reshape{new_shape}, l); p.add_instruction(migraph::reshape{new_shape}, l);
p.compile(rtg::cpu::cpu_target{}); p.compile(migraph::cpu::cpu_target{});
auto result = p.eval({}); auto result = p.eval({});
std::vector<float> results_vector(3); std::vector<float> results_vector(3);
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); }); result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
EXPECT(test::verify_range(results_vector, data)); EXPECT(test::verify_range(results_vector, data));
} }
{ {
rtg::program p; migraph::program p;
auto l = p.add_literal(rtg::literal{a_shape, data}); auto l = p.add_literal(migraph::literal{a_shape, data});
std::vector<int64_t> new_shape = {1, 3, 4, 2}; std::vector<int64_t> new_shape = {1, 3, 4, 2};
p.add_instruction(rtg::reshape{new_shape}, l); p.add_instruction(migraph::reshape{new_shape}, l);
p.compile(rtg::cpu::cpu_target{}); p.compile(migraph::cpu::cpu_target{});
auto result = p.eval({}); auto result = p.eval({});
std::vector<float> results_vector(3); std::vector<float> results_vector(3);
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); }); result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
...@@ -204,7 +204,7 @@ void reshape_test() ...@@ -204,7 +204,7 @@ void reshape_test()
void gemm_test() void gemm_test()
{ {
rtg::program p; migraph::program p;
std::vector<float> a = {-0.00925222, 0.56250403, 0.70107397, 0.75402161, -0.505885, std::vector<float> a = {-0.00925222, 0.56250403, 0.70107397, 0.75402161, -0.505885,
1.33628943, -0.11413, -0.31270559, 1.59336732, -0.19361027, 1.33628943, -0.11413, -0.31270559, 1.59336732, -0.19361027,
-0.91620867, 0.40108416, -0.06969921, 0.68483471, -0.39906632, -0.91620867, 0.40108416, -0.06969921, 0.68483471, -0.39906632,
...@@ -236,12 +236,12 @@ void gemm_test() ...@@ -236,12 +236,12 @@ void gemm_test()
-1.29885596e+00, -1.29885596e+00,
2.16294914e+00, 2.16294914e+00,
-1.48101497e-01}; -1.48101497e-01};
rtg::shape a_shape{rtg::shape::float_type, {4, 5}}; migraph::shape a_shape{migraph::shape::float_type, {4, 5}};
auto al = p.add_literal(rtg::literal{a_shape, a}); auto al = p.add_literal(migraph::literal{a_shape, a});
rtg::shape b_shape{rtg::shape::float_type, {5, 3}}; migraph::shape b_shape{migraph::shape::float_type, {5, 3}};
auto bl = p.add_literal(rtg::literal{b_shape, b}); auto bl = p.add_literal(migraph::literal{b_shape, b});
p.add_instruction(rtg::gemm{}, al, bl); p.add_instruction(migraph::gemm{}, al, bl);
p.compile(rtg::cpu::cpu_target{}); p.compile(migraph::cpu::cpu_target{});
auto result = p.eval({}); auto result = p.eval({});
std::vector<float> results_vector(12); std::vector<float> results_vector(12);
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); }); result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
...@@ -254,7 +254,7 @@ void gemm_test() ...@@ -254,7 +254,7 @@ void gemm_test()
void softmax_test() void softmax_test()
{ {
rtg::program p; migraph::program p;
std::vector<float> a = { std::vector<float> a = {
-5.61869681e-01, 9.07827199e-01, 1.29255986e+00, 3.18533443e-02, -1.22183852e-03, -5.61869681e-01, 9.07827199e-01, 1.29255986e+00, 3.18533443e-02, -1.22183852e-03,
-2.83830553e-01, -1.03245842e+00, -9.28322077e-01, -8.82696748e-01, 1.11327164e-01, -2.83830553e-01, -1.03245842e+00, -9.28322077e-01, -8.82696748e-01, 1.11327164e-01,
...@@ -301,10 +301,10 @@ void softmax_test() ...@@ -301,10 +301,10 @@ void softmax_test()
0.17377149, 0.76075399, 0.20071237, 0.32632929, 0.36892858, 0.09416146, 0.26656723, 0.17377149, 0.76075399, 0.20071237, 0.32632929, 0.36892858, 0.09416146, 0.26656723,
0.42914796}; 0.42914796};
rtg::shape a_shape{rtg::shape::float_type, {5, 3, 4, 2}}; migraph::shape a_shape{migraph::shape::float_type, {5, 3, 4, 2}};
auto al = p.add_literal(rtg::literal{a_shape, a}); auto al = p.add_literal(migraph::literal{a_shape, a});
p.add_instruction(rtg::softmax{}, al); p.add_instruction(migraph::softmax{}, al);
p.compile(rtg::cpu::cpu_target{}); p.compile(migraph::cpu::cpu_target{});
auto result = p.eval({}); auto result = p.eval({});
std::vector<float> results_vector(120); std::vector<float> results_vector(120);
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); }); result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
...@@ -313,7 +313,7 @@ void softmax_test() ...@@ -313,7 +313,7 @@ void softmax_test()
void conv2d_test() void conv2d_test()
{ {
rtg::program p; migraph::program p;
std::vector<float> a = { std::vector<float> a = {
2.71567607, -0.9960829, 0.91671127, 0.28140706, 0.63235772, 0.08077253, 0.80927712, 2.71567607, -0.9960829, 0.91671127, 0.28140706, 0.63235772, 0.08077253, 0.80927712,
-0.59108931, -1.05421555, -2.76622486, -0.85044265, -0.52049929, 0.67726439, -0.65290606, -0.59108931, -1.05421555, -2.76622486, -0.85044265, -0.52049929, 0.67726439, -0.65290606,
...@@ -359,14 +359,14 @@ void conv2d_test() ...@@ -359,14 +359,14 @@ void conv2d_test()
0.71606487, 0.71606487,
-0.55201721, -0.55201721,
-0.46427044}; -0.46427044};
rtg::shape a_shape{rtg::shape::float_type, {2, 3, 4, 4}}; migraph::shape a_shape{migraph::shape::float_type, {2, 3, 4, 4}};
auto al = p.add_literal(rtg::literal{a_shape, a}); auto al = p.add_literal(migraph::literal{a_shape, a});
rtg::shape c_shape{rtg::shape::float_type, {2, 3, 3, 3}}; migraph::shape c_shape{migraph::shape::float_type, {2, 3, 3, 3}};
auto cl = p.add_literal(rtg::literal{c_shape, c}); auto cl = p.add_literal(migraph::literal{c_shape, c});
p.add_instruction(rtg::convolution{}, al, cl); p.add_instruction(migraph::convolution{}, al, cl);
p.compile(rtg::cpu::cpu_target{}); p.compile(migraph::cpu::cpu_target{});
auto result = p.eval({}); auto result = p.eval({});
std::vector<float> results_vector(16); std::vector<float> results_vector(16);
...@@ -376,7 +376,7 @@ void conv2d_test() ...@@ -376,7 +376,7 @@ void conv2d_test()
void conv2d_padding_test() void conv2d_padding_test()
{ {
rtg::program p; migraph::program p;
std::vector<float> a = { std::vector<float> a = {
2.71567607, -0.9960829, 0.91671127, 0.28140706, 0.63235772, 0.08077253, 0.80927712, 2.71567607, -0.9960829, 0.91671127, 0.28140706, 0.63235772, 0.08077253, 0.80927712,
-0.59108931, -1.05421555, -2.76622486, -0.85044265, -0.52049929, 0.67726439, -0.65290606, -0.59108931, -1.05421555, -2.76622486, -0.85044265, -0.52049929, 0.67726439, -0.65290606,
...@@ -415,14 +415,14 @@ void conv2d_padding_test() ...@@ -415,14 +415,14 @@ void conv2d_padding_test()
-0.20369984, -0.83037728, -1.40423918, -0.46160448, -0.22944322, 0.36074194, 0.49579027, -0.20369984, -0.83037728, -1.40423918, -0.46160448, -0.22944322, 0.36074194, 0.49579027,
0.46527559}; 0.46527559};
rtg::shape a_shape{rtg::shape::float_type, {2, 3, 4, 4}}; migraph::shape a_shape{migraph::shape::float_type, {2, 3, 4, 4}};
auto al = p.add_literal(rtg::literal{a_shape, a}); auto al = p.add_literal(migraph::literal{a_shape, a});
rtg::shape c_shape{rtg::shape::float_type, {2, 3, 3, 3}}; migraph::shape c_shape{migraph::shape::float_type, {2, 3, 3, 3}};
auto cl = p.add_literal(rtg::literal{c_shape, c}); auto cl = p.add_literal(migraph::literal{c_shape, c});
p.add_instruction(rtg::convolution{{{1, 1}}, {{1, 1}}}, al, cl); p.add_instruction(migraph::convolution{{{1, 1}}, {{1, 1}}}, al, cl);
p.compile(rtg::cpu::cpu_target{}); p.compile(migraph::cpu::cpu_target{});
auto result = p.eval({}); auto result = p.eval({});
std::vector<float> results_vector(64); std::vector<float> results_vector(64);
...@@ -432,7 +432,7 @@ void conv2d_padding_test() ...@@ -432,7 +432,7 @@ void conv2d_padding_test()
void conv2d_padding_stride_test() void conv2d_padding_stride_test()
{ {
rtg::program p; migraph::program p;
std::vector<float> a = { std::vector<float> a = {
2.71567607, -0.9960829, 0.91671127, 0.28140706, 0.63235772, 0.08077253, 0.80927712, 2.71567607, -0.9960829, 0.91671127, 0.28140706, 0.63235772, 0.08077253, 0.80927712,
-0.59108931, -1.05421555, -2.76622486, -0.85044265, -0.52049929, 0.67726439, -0.65290606, -0.59108931, -1.05421555, -2.76622486, -0.85044265, -0.52049929, 0.67726439, -0.65290606,
...@@ -476,14 +476,14 @@ void conv2d_padding_stride_test() ...@@ -476,14 +476,14 @@ void conv2d_padding_stride_test()
-0.16138598, -0.16138598,
0.79344082}; 0.79344082};
rtg::shape a_shape{rtg::shape::float_type, {2, 3, 4, 4}}; migraph::shape a_shape{migraph::shape::float_type, {2, 3, 4, 4}};
auto al = p.add_literal(rtg::literal{a_shape, a}); auto al = p.add_literal(migraph::literal{a_shape, a});
rtg::shape c_shape{rtg::shape::float_type, {2, 3, 3, 3}}; migraph::shape c_shape{migraph::shape::float_type, {2, 3, 3, 3}};
auto cl = p.add_literal(rtg::literal{c_shape, c}); auto cl = p.add_literal(migraph::literal{c_shape, c});
p.add_instruction(rtg::convolution{{{1, 1}}, {{2, 2}}}, al, cl); p.add_instruction(migraph::convolution{{{1, 1}}, {{2, 2}}}, al, cl);
p.compile(rtg::cpu::cpu_target{}); p.compile(migraph::cpu::cpu_target{});
auto result = p.eval({}); auto result = p.eval({});
std::vector<float> results_vector(16); std::vector<float> results_vector(16);
...@@ -493,16 +493,16 @@ void conv2d_padding_stride_test() ...@@ -493,16 +493,16 @@ void conv2d_padding_stride_test()
void transpose_test() void transpose_test()
{ {
rtg::shape a_shape{rtg::shape::float_type, {1, 2, 2, 3}}; migraph::shape a_shape{migraph::shape::float_type, {1, 2, 2, 3}};
std::vector<float> data(12); std::vector<float> data(12);
std::iota(data.begin(), data.end(), 0); std::iota(data.begin(), data.end(), 0);
{ {
rtg::program p; migraph::program p;
auto l = p.add_literal(rtg::literal{a_shape, data}); auto l = p.add_literal(migraph::literal{a_shape, data});
std::vector<int64_t> perm = {0, 3, 1, 2}; std::vector<int64_t> perm = {0, 3, 1, 2};
p.add_instruction(rtg::transpose{perm}, l); p.add_instruction(migraph::transpose{perm}, l);
p.compile(rtg::cpu::cpu_target{}); p.compile(migraph::cpu::cpu_target{});
auto result = p.eval({}); auto result = p.eval({});
result.visit([&](auto output) { result.visit([&](auto output) {
...@@ -513,12 +513,12 @@ void transpose_test() ...@@ -513,12 +513,12 @@ void transpose_test()
}); });
} }
{ {
rtg::program p; migraph::program p;
auto l = p.add_literal(rtg::literal{a_shape, data}); auto l = p.add_literal(migraph::literal{a_shape, data});
std::vector<int64_t> perm = {0, 3, 1, 2}; std::vector<int64_t> perm = {0, 3, 1, 2};
auto result = p.add_instruction(rtg::transpose{perm}, l); auto result = p.add_instruction(migraph::transpose{perm}, l);
p.add_instruction(rtg::contiguous{}, result); p.add_instruction(migraph::contiguous{}, result);
p.compile(rtg::cpu::cpu_target{}); p.compile(migraph::cpu::cpu_target{});
auto result2 = p.eval({}); auto result2 = p.eval({});
std::vector<float> results_vector(12); std::vector<float> results_vector(12);
...@@ -530,14 +530,14 @@ void transpose_test() ...@@ -530,14 +530,14 @@ void transpose_test()
void contiguous_test() void contiguous_test()
{ {
rtg::shape a_shape{rtg::shape::float_type, {1, 3, 2, 2}, {12, 1, 6, 3}}; migraph::shape a_shape{migraph::shape::float_type, {1, 3, 2, 2}, {12, 1, 6, 3}};
std::vector<float> data(12); std::vector<float> data(12);
std::iota(data.begin(), data.end(), 0); std::iota(data.begin(), data.end(), 0);
rtg::program p; migraph::program p;
auto l = p.add_literal(rtg::literal{a_shape, data}); auto l = p.add_literal(migraph::literal{a_shape, data});
p.add_instruction(rtg::contiguous{}, l); p.add_instruction(migraph::contiguous{}, l);
p.compile(rtg::cpu::cpu_target{}); p.compile(migraph::cpu::cpu_target{});
auto result = p.eval({}); auto result = p.eval({});
std::vector<float> results_vector(12); std::vector<float> results_vector(12);
......
test/eval_test.cpp
View file @ eea003a5
#include <rtg/program.hpp> #include <migraph/program.hpp>
#include <rtg/argument.hpp> #include <migraph/argument.hpp>
#include <rtg/shape.hpp> #include <migraph/shape.hpp>
#include <sstream> #include <sstream>
#include "test.hpp" #include "test.hpp"
struct sum_op struct sum_op
{ {
std::string name() const { return "sum"; } std::string name() const { return "sum"; }
rtg::argument compute(rtg::context&, rtg::shape, std::vector<rtg::argument> args) const migraph::argument compute(migraph::context&, migraph::shape, std::vector<migraph::argument> args) const
{ {
rtg::argument result; migraph::argument result;
if(args.size() != 2) if(args.size() != 2)
RTG_THROW("Wrong args"); MIGRAPH_THROW("Wrong args");
if(args[0].get_shape() != args[1].get_shape()) if(args[0].get_shape() != args[1].get_shape())
RTG_THROW("Wrong args"); MIGRAPH_THROW("Wrong args");
if(args[0].get_shape().lens().size() != 1) if(args[0].get_shape().lens().size() != 1)
RTG_THROW("Wrong args"); MIGRAPH_THROW("Wrong args");
if(args[0].get_shape().lens().front() != 1) if(args[0].get_shape().lens().front() != 1)
RTG_THROW("Wrong args"); MIGRAPH_THROW("Wrong args");
args[0].visit_at([&](auto x) { args[0].visit_at([&](auto x) {
args[1].visit_at([&](auto y) { result = rtg::literal{x + y}.get_argument(); }); args[1].visit_at([&](auto y) { result = migraph::literal{x + y}.get_argument(); });
}); });
return result; return result;
} }
rtg::shape compute_shape(std::vector<rtg::shape> inputs) const migraph::shape compute_shape(std::vector<migraph::shape> inputs) const
{ {
if(inputs.size() != 2) if(inputs.size() != 2)
RTG_THROW("Wrong inputs"); MIGRAPH_THROW("Wrong inputs");
return inputs.front(); return inputs.front();
} }
}; };
...@@ -37,28 +37,28 @@ struct sum_op ...@@ -37,28 +37,28 @@ struct sum_op
struct minus_op struct minus_op
{ {
std::string name() const { return "minus"; } std::string name() const { return "minus"; }
rtg::argument compute(rtg::context&, rtg::shape, std::vector<rtg::argument> args) const migraph::argument compute(migraph::context&, migraph::shape, std::vector<migraph::argument> args) const
{ {
rtg::argument result; migraph::argument result;
if(args.size() != 2) if(args.size() != 2)
RTG_THROW("Wrong args"); MIGRAPH_THROW("Wrong args");
if(args[0].get_shape() != args[1].get_shape()) if(args[0].get_shape() != args[1].get_shape())
RTG_THROW("Wrong args"); MIGRAPH_THROW("Wrong args");
if(args[0].get_shape().lens().size() != 1) if(args[0].get_shape().lens().size() != 1)
RTG_THROW("Wrong args"); MIGRAPH_THROW("Wrong args");
if(args[0].get_shape().lens().front() != 1) if(args[0].get_shape().lens().front() != 1)
RTG_THROW("Wrong args"); MIGRAPH_THROW("Wrong args");
args[0].visit_at([&](auto x) { args[0].visit_at([&](auto x) {
args[1].visit_at([&](auto y) { result = rtg::literal{x - y}.get_argument(); }); args[1].visit_at([&](auto y) { result = migraph::literal{x - y}.get_argument(); });
}); });
return result; return result;
} }
rtg::shape compute_shape(std::vector<rtg::shape> inputs) const migraph::shape compute_shape(std::vector<migraph::shape> inputs) const
{ {
if(inputs.size() != 2) if(inputs.size() != 2)
RTG_THROW("Wrong inputs"); MIGRAPH_THROW("Wrong inputs");
return inputs.front(); return inputs.front();
} }
}; };
...@@ -66,25 +66,25 @@ struct minus_op ...@@ -66,25 +66,25 @@ struct minus_op
struct id_target struct id_target
{ {
std::string name() const { return "id"; } std::string name() const { return "id"; }
void apply(rtg::program&) const {} void apply(migraph::program&) const {}
rtg::context get_context() const { return {}; } migraph::context get_context() const { return {}; }
}; };
void literal_test1() void literal_test1()
{ {
rtg::program p; migraph::program p;
auto one = p.add_literal(1); auto one = p.add_literal(1);
auto two = p.add_literal(2); auto two = p.add_literal(2);
p.add_instruction(sum_op{}, one, two); p.add_instruction(sum_op{}, one, two);
auto result = p.eval({}); auto result = p.eval({});
EXPECT(result == rtg::literal{3}); EXPECT(result == migraph::literal{3});
EXPECT(result != rtg::literal{4}); EXPECT(result != migraph::literal{4});
} }
void literal_test2() void literal_test2()
{ {
rtg::program p; migraph::program p;
auto one = p.add_literal(1); auto one = p.add_literal(1);
auto two = p.add_literal(2); auto two = p.add_literal(2);
...@@ -92,15 +92,15 @@ void literal_test2() ...@@ -92,15 +92,15 @@ void literal_test2()
p.add_instruction(sum_op{}, sum1, two); p.add_instruction(sum_op{}, sum1, two);
auto result = p.eval({}); auto result = p.eval({});
EXPECT(result == rtg::literal{5}); EXPECT(result == migraph::literal{5});
EXPECT(result != rtg::literal{3}); EXPECT(result != migraph::literal{3});
} }
void print_test() void print_test()
{ {
rtg::program p; migraph::program p;
auto x = p.add_parameter("x", {rtg::shape::int64_type}); auto x = p.add_parameter("x", {migraph::shape::int64_type});
auto two = p.add_literal(2); auto two = p.add_literal(2);
p.add_instruction(sum_op{}, x, two); p.add_instruction(sum_op{}, x, two);
...@@ -112,21 +112,21 @@ void print_test() ...@@ -112,21 +112,21 @@ void print_test()
void param_test() void param_test()
{ {
rtg::program p; migraph::program p;
auto x = p.add_parameter("x", {rtg::shape::int64_type}); auto x = p.add_parameter("x", {migraph::shape::int64_type});
auto y = p.add_parameter("y", {rtg::shape::int64_type}); auto y = p.add_parameter("y", {migraph::shape::int64_type});
p.add_instruction(sum_op{}, x, y); p.add_instruction(sum_op{}, x, y);
auto result = auto result =
p.eval({{"x", rtg::literal{1}.get_argument()}, {"y", rtg::literal{2}.get_argument()}}); p.eval({{"x", migraph::literal{1}.get_argument()}, {"y", migraph::literal{2}.get_argument()}});
EXPECT(result == rtg::literal{3}); EXPECT(result == migraph::literal{3});
EXPECT(result != rtg::literal{4}); EXPECT(result != migraph::literal{4});
} }
void replace_test() void replace_test()
{ {
rtg::program p; migraph::program p;
auto one = p.add_literal(1); auto one = p.add_literal(1);
auto two = p.add_literal(2); auto two = p.add_literal(2);
...@@ -134,13 +134,13 @@ void replace_test() ...@@ -134,13 +134,13 @@ void replace_test()
p.replace_instruction(sum, minus_op{}, two, one); p.replace_instruction(sum, minus_op{}, two, one);
auto result = p.eval({}); auto result = p.eval({});
EXPECT(result == rtg::literal{1}); EXPECT(result == migraph::literal{1});
EXPECT(result != rtg::literal{3}); EXPECT(result != migraph::literal{3});
} }
void insert_replace_test() void insert_replace_test()
{ {
rtg::program p; migraph::program p;
auto one = p.add_literal(1); auto one = p.add_literal(1);
auto two = p.add_literal(2); auto two = p.add_literal(2);
...@@ -151,21 +151,21 @@ void insert_replace_test() ...@@ -151,21 +151,21 @@ void insert_replace_test()
p.replace_instruction(sum1, minus_op{}, sum0, two); p.replace_instruction(sum1, minus_op{}, sum0, two);
auto result = p.eval({}); auto result = p.eval({});
EXPECT(result == rtg::literal{4}); EXPECT(result == migraph::literal{4});
EXPECT(result != rtg::literal{5}); EXPECT(result != migraph::literal{5});
} }
void target_test() void target_test()
{ {
rtg::program p; migraph::program p;
auto one = p.add_literal(1); auto one = p.add_literal(1);
auto two = p.add_literal(2); auto two = p.add_literal(2);
p.add_instruction(sum_op{}, one, two); p.add_instruction(sum_op{}, one, two);
p.compile(id_target{}); p.compile(id_target{});
auto result = p.eval({}); auto result = p.eval({});
EXPECT(result == rtg::literal{3}); EXPECT(result == migraph::literal{3});
EXPECT(result != rtg::literal{4}); EXPECT(result != migraph::literal{4});
} }
int main() int main()
......
test/include/test.hpp
View file @ eea003a5
...@@ -4,8 +4,8 @@ ...@@ -4,8 +4,8 @@
#include <cstdlib> #include <cstdlib>
#include <iostream> #include <iostream>
#ifndef RTG_GUARD_TEST_TEST_HPP #ifndef MIGRAPH_GUARD_TEST_TEST_HPP
#define RTG_GUARD_TEST_TEST_HPP #define MIGRAPH_GUARD_TEST_TEST_HPP
namespace test { namespace test {
// NOLINTNEXTLINE // NOLINTNEXTLINE
......
test/include/verify.hpp
View file @ eea003a5
#ifndef RTG_GUARD_VERIFY_HPP #ifndef MIGRAPH_GUARD_VERIFY_HPP
#define RTG_GUARD_VERIFY_HPP #define MIGRAPH_GUARD_VERIFY_HPP
#include <algorithm> #include <algorithm>
#include <cmath> #include <cmath>
......
test/literal_test.cpp
View file @ eea003a5
#include <rtg/literal.hpp> #include <migraph/literal.hpp>
#include <sstream> #include <sstream>
#include <string> #include <string>
#include "test.hpp" #include "test.hpp"
void literal_test() void literal_test()
{ {
EXPECT(rtg::literal{1} == rtg::literal{1}); EXPECT(migraph::literal{1} == migraph::literal{1});
EXPECT(rtg::literal{1} != rtg::literal{2}); EXPECT(migraph::literal{1} != migraph::literal{2});
EXPECT(rtg::literal{} == rtg::literal{}); EXPECT(migraph::literal{} == migraph::literal{});
EXPECT(rtg::literal{} != rtg::literal{2}); EXPECT(migraph::literal{} != migraph::literal{2});
rtg::literal l1{1}; migraph::literal l1{1};
rtg::literal l2 = l1; // NOLINT migraph::literal l2 = l1; // NOLINT
EXPECT(l1 == l2); EXPECT(l1 == l2);
EXPECT(l1.at<int>(0) == 1); EXPECT(l1.at<int>(0) == 1);
EXPECT(!l1.empty()); EXPECT(!l1.empty());
EXPECT(!l2.empty()); EXPECT(!l2.empty());
rtg::literal l3{}; migraph::literal l3{};
rtg::literal l4{}; migraph::literal l4{};
EXPECT(l3 == l4); EXPECT(l3 == l4);
EXPECT(l3.empty()); EXPECT(l3.empty());
EXPECT(l4.empty()); EXPECT(l4.empty());
...@@ -27,7 +27,7 @@ void literal_test() ...@@ -27,7 +27,7 @@ void literal_test()
void literal_os1() void literal_os1()
{ {
rtg::literal l{1}; migraph::literal l{1};
std::stringstream ss; std::stringstream ss;
ss << l; ss << l;
EXPECT(ss.str() == "1"); EXPECT(ss.str() == "1");
...@@ -35,7 +35,7 @@ void literal_os1() ...@@ -35,7 +35,7 @@ void literal_os1()
void literal_os2() void literal_os2()
{ {
rtg::literal l{}; migraph::literal l{};
std::stringstream ss; std::stringstream ss;
ss << l; ss << l;
EXPECT(ss.str().empty()); EXPECT(ss.str().empty());
...@@ -43,8 +43,8 @@ void literal_os2() ...@@ -43,8 +43,8 @@ void literal_os2()
void literal_os3() void literal_os3()
{ {
rtg::shape s{rtg::shape::int64_type, {3}}; migraph::shape s{migraph::shape::int64_type, {3}};
rtg::literal l{s, {1, 2, 3}}; migraph::literal l{s, {1, 2, 3}};
std::stringstream ss; std::stringstream ss;
ss << l; ss << l;
EXPECT(ss.str() == "1, 2, 3"); EXPECT(ss.str() == "1, 2, 3");
......
test/miopen/miopen.cpp
View file @ eea003a5
#include <rtg/program.hpp> #include <migraph/program.hpp>
#include <rtg/operators.hpp> #include <migraph/operators.hpp>
#include <rtg/generate.hpp> #include <migraph/generate.hpp>
#include <rtg/cpu/cpu_target.hpp> #include <migraph/cpu/cpu_target.hpp>
#include <rtg/miopen/miopen_target.hpp> #include <migraph/miopen/miopen_target.hpp>
#include <rtg/miopen/miopen.hpp> #include <migraph/miopen/miopen.hpp>
#include <rtg/miopen/hip.hpp> #include <migraph/miopen/hip.hpp>
#include <rtg/manage_ptr.hpp> #include <migraph/manage_ptr.hpp>
#include <miopen/miopen.h> #include <miopen/miopen.h>
...@@ -14,30 +14,30 @@ ...@@ -14,30 +14,30 @@
#include "verify.hpp" #include "verify.hpp"
template <class V> template <class V>
rtg::argument run_cpu() migraph::argument run_cpu()
{ {
V v; V v;
auto p = v.create_program(); auto p = v.create_program();
p.compile(rtg::cpu::cpu_target{}); p.compile(migraph::cpu::cpu_target{});
return p.eval(v.create_params()); return p.eval(v.create_params());
} }
template <class V> template <class V>
rtg::argument run_gpu() migraph::argument run_gpu()
{ {
V v; V v;
auto p = v.create_program(); auto p = v.create_program();
p.compile(rtg::miopen::miopen_target{}); p.compile(migraph::miopen::miopen_target{});
auto m = v.create_params(); auto m = v.create_params();
for(auto&& e : m) for(auto&& e : m)
{ {
e.second = rtg::miopen::to_gpu(e.second); e.second = migraph::miopen::to_gpu(e.second);
} }
m["output"] = rtg::miopen::to_gpu(rtg::generate_argument(p.get_parameter_shape("output"))); m["output"] = migraph::miopen::to_gpu(migraph::generate_argument(p.get_parameter_shape("output")));
return rtg::miopen::from_gpu(p.eval(m)); return migraph::miopen::from_gpu(p.eval(m));
} }
template <class V> template <class V>
...@@ -50,106 +50,106 @@ void verify_program() ...@@ -50,106 +50,106 @@ void verify_program()
struct test_add struct test_add
{ {
rtg::program create_program() const migraph::program create_program() const
{ {
rtg::program p; migraph::program p;
rtg::shape s{rtg::shape::float_type, {3}}; migraph::shape s{migraph::shape::float_type, {3}};
auto x = p.add_parameter("x", s); auto x = p.add_parameter("x", s);
auto y = p.add_parameter("y", s); auto y = p.add_parameter("y", s);
p.add_instruction(rtg::add{}, x, y); p.add_instruction(migraph::add{}, x, y);
return p; return p;
} }
rtg::program::parameter_map create_params() const migraph::program::parameter_map create_params() const
{ {
rtg::program::parameter_map m; migraph::program::parameter_map m;
m["x"] = rtg::generate_argument({rtg::shape::float_type, {3}}); m["x"] = migraph::generate_argument({migraph::shape::float_type, {3}});
m["y"] = rtg::generate_argument({rtg::shape::float_type, {3}}); m["y"] = migraph::generate_argument({migraph::shape::float_type, {3}});
return m; return m;
} }
}; };
struct test_add_broadcast struct test_add_broadcast
{ {
rtg::program create_program() const migraph::program create_program() const
{ {
rtg::program p; migraph::program p;
rtg::shape s{rtg::shape::float_type, {3}}; migraph::shape s{migraph::shape::float_type, {3}};
auto x = p.add_parameter("x", {rtg::shape::float_type, {2, 2, 3}}); auto x = p.add_parameter("x", {migraph::shape::float_type, {2, 2, 3}});
auto y = p.add_parameter("y", {rtg::shape::float_type, {2, 2}}); auto y = p.add_parameter("y", {migraph::shape::float_type, {2, 2}});
auto by = p.add_instruction(rtg::broadcast{0}, x, y); auto by = p.add_instruction(migraph::broadcast{0}, x, y);
p.add_instruction(rtg::add{}, x, by); p.add_instruction(migraph::add{}, x, by);
return p; return p;
} }
rtg::program::parameter_map create_params() const migraph::program::parameter_map create_params() const
{ {
rtg::program::parameter_map m; migraph::program::parameter_map m;
m["x"] = rtg::generate_argument({rtg::shape::float_type, {2, 2, 3}}); m["x"] = migraph::generate_argument({migraph::shape::float_type, {2, 2, 3}});
m["y"] = rtg::generate_argument({rtg::shape::float_type, {2, 2}}); m["y"] = migraph::generate_argument({migraph::shape::float_type, {2, 2}});
return m; return m;
} }
}; };
struct test_conv_relu struct test_conv_relu
{ {
rtg::program create_program() const migraph::program create_program() const
{ {
rtg::program p; migraph::program p;
auto input = p.add_parameter("x", rtg::shape{rtg::shape::float_type, {4, 3, 3, 3}}); auto input = p.add_parameter("x", migraph::shape{migraph::shape::float_type, {4, 3, 3, 3}});
auto weights = p.add_parameter("w", rtg::shape{rtg::shape::float_type, {4, 3, 3, 3}}); auto weights = p.add_parameter("w", migraph::shape{migraph::shape::float_type, {4, 3, 3, 3}});
auto conv = p.add_instruction(rtg::convolution{}, input, weights); auto conv = p.add_instruction(migraph::convolution{}, input, weights);
p.add_instruction(rtg::activation{"relu"}, conv); p.add_instruction(migraph::activation{"relu"}, conv);
return p; return p;
} }
rtg::program::parameter_map create_params() const migraph::program::parameter_map create_params() const
{ {
rtg::program::parameter_map m; migraph::program::parameter_map m;
m["x"] = rtg::generate_argument({rtg::shape::float_type, {4, 3, 3, 3}}); m["x"] = migraph::generate_argument({migraph::shape::float_type, {4, 3, 3, 3}});
m["w"] = rtg::generate_argument({rtg::shape::float_type, {4, 3, 3, 3}}); m["w"] = migraph::generate_argument({migraph::shape::float_type, {4, 3, 3, 3}});
return m; return m;
} }
}; };
struct test_conv_pooling struct test_conv_pooling
{ {
rtg::program create_program() const migraph::program create_program() const
{ {
rtg::program p; migraph::program p;
auto input = p.add_parameter("x", rtg::shape{rtg::shape::float_type, {4, 3, 32, 32}}); auto input = p.add_parameter("x", migraph::shape{migraph::shape::float_type, {4, 3, 32, 32}});
auto weights = p.add_parameter("w", rtg::shape{rtg::shape::float_type, {4, 3, 3, 3}}); auto weights = p.add_parameter("w", migraph::shape{migraph::shape::float_type, {4, 3, 3, 3}});
auto conv = p.add_instruction(rtg::convolution{}, input, weights); auto conv = p.add_instruction(migraph::convolution{}, input, weights);
auto pooling = p.add_instruction(rtg::pooling{"max"}, conv); auto pooling = p.add_instruction(migraph::pooling{"max"}, conv);
p.add_instruction(rtg::activation{"relu"}, pooling); p.add_instruction(migraph::activation{"relu"}, pooling);
return p; return p;
} }
rtg::program::parameter_map create_params() const migraph::program::parameter_map create_params() const
{ {
rtg::program::parameter_map m; migraph::program::parameter_map m;
m["x"] = rtg::generate_argument({rtg::shape::float_type, {4, 3, 32, 32}}); m["x"] = migraph::generate_argument({migraph::shape::float_type, {4, 3, 32, 32}});
m["w"] = rtg::generate_argument({rtg::shape::float_type, {4, 3, 3, 3}}); m["w"] = migraph::generate_argument({migraph::shape::float_type, {4, 3, 3, 3}});
return m; return m;
} }
}; };
struct test_gemm struct test_gemm
{ {
rtg::program create_program() const migraph::program create_program() const
{ {
rtg::program p; migraph::program p;
auto a = p.add_parameter("a", rtg::shape{rtg::shape::float_type, {4, 5}}); auto a = p.add_parameter("a", migraph::shape{migraph::shape::float_type, {4, 5}});
auto b = p.add_parameter("b", rtg::shape{rtg::shape::float_type, {5, 3}}); auto b = p.add_parameter("b", migraph::shape{migraph::shape::float_type, {5, 3}});
p.add_instruction(rtg::gemm{}, a, b); p.add_instruction(migraph::gemm{}, a, b);
return p; return p;
} }
rtg::program::parameter_map create_params() const migraph::program::parameter_map create_params() const
{ {
rtg::program::parameter_map m; migraph::program::parameter_map m;
m["a"] = rtg::generate_argument({rtg::shape::float_type, {4, 5}}); m["a"] = migraph::generate_argument({migraph::shape::float_type, {4, 5}});
m["b"] = rtg::generate_argument({rtg::shape::float_type, {5, 3}}); m["b"] = migraph::generate_argument({migraph::shape::float_type, {5, 3}});
return m; return m;
} }
}; };
......
test/operation.cpp
View file @ eea003a5
#include <rtg/operation.hpp> #include <migraph/operation.hpp>
#include <sstream> #include <sstream>
#include <string> #include <string>
#include "test.hpp" #include "test.hpp"
...@@ -8,10 +8,10 @@ struct simple_operation ...@@ -8,10 +8,10 @@ struct simple_operation
{ {
int data = 1; int data = 1;
std::string name() const { return "simple"; } std::string name() const { return "simple"; }
rtg::shape compute_shape(std::vector<rtg::shape>) const { RTG_THROW("not computable"); } migraph::shape compute_shape(std::vector<migraph::shape>) const { MIGRAPH_THROW("not computable"); }
rtg::argument compute(rtg::context&, rtg::shape, std::vector<rtg::argument>) const migraph::argument compute(migraph::context&, migraph::shape, std::vector<migraph::argument>) const
{ {
RTG_THROW("not computable"); MIGRAPH_THROW("not computable");
} }
friend std::ostream& operator<<(std::ostream& os, const simple_operation& op) friend std::ostream& operator<<(std::ostream& os, const simple_operation& op)
{ {
...@@ -23,18 +23,18 @@ struct simple_operation ...@@ -23,18 +23,18 @@ struct simple_operation
struct simple_operation_no_print struct simple_operation_no_print
{ {
std::string name() const { return "simple"; } std::string name() const { return "simple"; }
rtg::shape compute_shape(std::vector<rtg::shape>) const { RTG_THROW("not computable"); } migraph::shape compute_shape(std::vector<migraph::shape>) const { MIGRAPH_THROW("not computable"); }
rtg::argument compute(rtg::context&, rtg::shape, std::vector<rtg::argument>) const migraph::argument compute(migraph::context&, migraph::shape, std::vector<migraph::argument>) const
{ {
RTG_THROW("not computable"); MIGRAPH_THROW("not computable");
} }
}; };
void operation_copy_test() void operation_copy_test()
{ {
simple_operation s{}; simple_operation s{};
rtg::operation op1 = s; // NOLINT migraph::operation op1 = s; // NOLINT
rtg::operation op2 = op1; // NOLINT migraph::operation op2 = op1; // NOLINT
EXPECT(s.name() == op1.name()); EXPECT(s.name() == op1.name());
EXPECT(op2.name() == op1.name()); EXPECT(op2.name() == op1.name());
} }
...@@ -45,18 +45,18 @@ struct not_operation ...@@ -45,18 +45,18 @@ struct not_operation
void operation_any_cast() void operation_any_cast()
{ {
rtg::operation op1 = simple_operation{}; migraph::operation op1 = simple_operation{};
EXPECT(rtg::any_cast<simple_operation>(op1).data == 1); EXPECT(migraph::any_cast<simple_operation>(op1).data == 1);
EXPECT(rtg::any_cast<not_operation*>(&op1) == nullptr); EXPECT(migraph::any_cast<not_operation*>(&op1) == nullptr);
EXPECT(test::throws([&] { rtg::any_cast<not_operation&>(op1); })); EXPECT(test::throws([&] { migraph::any_cast<not_operation&>(op1); }));
rtg::operation op2 = simple_operation{2}; migraph::operation op2 = simple_operation{2};
EXPECT(rtg::any_cast<simple_operation>(op2).data == 2); EXPECT(migraph::any_cast<simple_operation>(op2).data == 2);
EXPECT(rtg::any_cast<not_operation*>(&op2) == nullptr); EXPECT(migraph::any_cast<not_operation*>(&op2) == nullptr);
} }
void operation_print() void operation_print()
{ {
rtg::operation op = simple_operation{}; migraph::operation op = simple_operation{};
std::stringstream ss; std::stringstream ss;
ss << op; ss << op;
std::string s = ss.str(); std::string s = ss.str();
...@@ -65,7 +65,7 @@ void operation_print() ...@@ -65,7 +65,7 @@ void operation_print()
void operation_default_print() void operation_default_print()
{ {
rtg::operation op = simple_operation_no_print{}; migraph::operation op = simple_operation_no_print{};
std::stringstream ss; std::stringstream ss;
ss << op; ss << op;
std::string s = ss.str(); std::string s = ss.str();
......
test/shape_test.cpp
View file @ eea003a5
#include <rtg/shape.hpp> #include <migraph/shape.hpp>
#include <array> #include <array>
#include <algorithm> #include <algorithm>
#include <numeric> #include <numeric>
...@@ -7,25 +7,25 @@ ...@@ -7,25 +7,25 @@
void test_shape_assign() void test_shape_assign()
{ {
rtg::shape s1{rtg::shape::float_type, {100, 32, 8, 8}}; migraph::shape s1{migraph::shape::float_type, {100, 32, 8, 8}};
rtg::shape s2 = s1; // NOLINT migraph::shape s2 = s1; // NOLINT
EXPECT(s1 == s2); EXPECT(s1 == s2);
EXPECT(!(s1 != s2)); EXPECT(!(s1 != s2));
} }
void test_shape_default() void test_shape_default()
{ {
rtg::shape s1{}; migraph::shape s1{};
rtg::shape s2{}; migraph::shape s2{};
EXPECT(s1 == s2); EXPECT(s1 == s2);
EXPECT(!(s1 != s2)); EXPECT(!(s1 != s2));
} }
void test_shape4() void test_shape4()
{ {
rtg::shape s{rtg::shape::float_type, {100, 32, 8, 8}}; migraph::shape s{migraph::shape::float_type, {100, 32, 8, 8}};
EXPECT(s.packed()); EXPECT(s.packed());
EXPECT(s.type() == rtg::shape::float_type); EXPECT(s.type() == migraph::shape::float_type);
EXPECT(s.lens()[0] == 100); EXPECT(s.lens()[0] == 100);
EXPECT(s.lens()[1] == 32); EXPECT(s.lens()[1] == 32);
EXPECT(s.lens()[2] == 8); EXPECT(s.lens()[2] == 8);
...@@ -67,9 +67,9 @@ void test_shape4_nonpacked() ...@@ -67,9 +67,9 @@ void test_shape4_nonpacked()
strides.rbegin() + 1, strides.rbegin() + 1,
std::multiplies<std::size_t>()); std::multiplies<std::size_t>());
rtg::shape s{rtg::shape::float_type, lens, strides}; migraph::shape s{migraph::shape::float_type, lens, strides};
EXPECT(!s.packed()); EXPECT(!s.packed());
EXPECT(s.type() == rtg::shape::float_type); EXPECT(s.type() == migraph::shape::float_type);
EXPECT(s.lens()[0] == 100); EXPECT(s.lens()[0] == 100);
EXPECT(s.lens()[1] == 32); EXPECT(s.lens()[1] == 32);
EXPECT(s.lens()[2] == 8); EXPECT(s.lens()[2] == 8);
......
tools/generate.sh
View file @ eea003a5
DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
ls -1 $DIR/include/ | xargs -n 1 -P $(nproc) -I{} -t bash -c "python3.6 $DIR/te.py $DIR/include/{} | clang-format-5.0 -style=file > $DIR/../src/include/rtg/{}" ls -1 $DIR/include/ | xargs -n 1 -P $(nproc) -I{} -t bash -c "python3.6 $DIR/te.py $DIR/include/{} | clang-format-5.0 -style=file > $DIR/../src/include/migraph/{}"
tools/include/context.hpp
View file @ eea003a5
#ifndef RTG_GUARD_CONTEXT_HPP #ifndef MIGRAPH_GUARD_CONTEXT_HPP
#define RTG_GUARD_CONTEXT_HPP #define MIGRAPH_GUARD_CONTEXT_HPP
namespace rtg { namespace migraph {
<% <%
interface('context') interface('context')
%> %>
} // namespace rtg } // namespace migraph
#endif #endif
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment