This patch fixes meson file and adds unittest to test both TRIV 2.3 and 2.4.
Signed-off-by: Yelin Jeong <yelini.jeong@samsung.com>
install_rpath : ne_libdir,
install_dir : join_paths(ne_bindir, 'apptests')
)
-test('apptest_tvn_triv2_bulk', apptest_tvn_triv2_bulk, env: testenv, args: [ join_paths(ne_datadir, 'testdata/TRIV240') ], timeout: 2000)
apptest_tvn_triv2 = executable ('apptest_tvn_triv2',
'tvn_triv2.cc',
install_rpath : ne_libdir,
install_dir : join_paths(ne_bindir, 'apptests')
)
-test('apptest_tvn_triv2', apptest_tvn_triv2, env: testenv, args: [ join_paths(ne_datadir, 'testdata/TRIV240/MOBILENET_V1') ], timeout: 100, suite: ['fast-test'])
apptest_tvn_triv2_dmabuf = executable ('apptest_tvn_triv2_dmabuf',
'tvn_triv2_dmabuf.cc',
install_rpath : ne_libdir,
install_dir : join_paths(ne_bindir, 'apptests')
)
-test('apptest_tvn_triv2_dmabuf', apptest_tvn_triv2_dmabuf, env: testenv, args: [ join_paths(ne_datadir, 'testdata/TRIV240/MOBILENET_V1') ], timeout : 100, suite: ['fast-test'])
-
-foreach model : models
- test('apptest_tvn_triv2_dmabuf_all', apptest_tvn_triv2_dmabuf, env: testenv, args: [ model ], timeout : 6000)
-endforeach
####
# TODO Disable this test until VD I/F sync. is done
install_rpath : ne_libdir,
install_dir : join_paths(ne_bindir, 'apptests')
)
-test('apptest_tvn_triv2_xml', apptest_tvn_triv2_xml, env: testenv, args: [join_paths(meson.source_root(), 'utils/resource/model.xml')], timeout: 100, suite: ['fast-test'])
apptest_tvn_triv2_profile = executable ('apptest_tvn_triv2_profile',
'tvn_triv2_profile.cc',
install_rpath : ne_libdir,
install_dir : join_paths(ne_bindir, 'apptests')
)
-test('apptest_tvn_triv2_profile', apptest_tvn_triv2_profile, env: testenv, args: [ join_paths(ne_datadir, 'testdata/TRIV240/MOBILENET_V1'), '-p', 'visa'], timeout: 100, suite: ['fast-test'])
executable ('apptest_tvn_triv2_profile_example',
'tvn_triv2_profile_example.cc',
install_rpath : ne_libdir,
install_dir : join_paths(ne_bindir, 'apptests')
)
-test('apptest_tvn_triv2_aging_0', apptest_tvn_triv2_aging, env: testenv, args: [ join_paths(ne_datadir, 'testdata/TRIV240/CONV_2D_300'), '1', '10'], suite: ['fast-test'])
-test('apptest_tvn_triv2_aging_1', apptest_tvn_triv2_aging, env: testenv, args: [ join_paths(ne_datadir, 'testdata/TRIV240/CONV_2D_300'), '2', '10'], suite: ['fast-test'])
-test('apptest_tvn_triv2_aging_2', apptest_tvn_triv2_aging, env: testenv, args: [ join_paths(ne_datadir, 'testdata/TRIV240/CONV_2D_300'), '3', '10'], suite: ['fast-test'])
-test('apptest_tvn_triv2_aging_3', apptest_tvn_triv2_aging, env: testenv, args: [ join_paths(ne_datadir, 'testdata/TRIV240/CONV_2D_300'), '4', '10'], suite: ['fast-test'])
-
-foreach model : models
- test('apptest_tvn_triv2_aging_all', apptest_tvn_triv2_aging, env: testenv, args: [ model, '4', '10' ], timeout : 6000)
-endforeach
apptest_tvn_triv2_interleave = executable ('apptest_tvn_triv2_interleave',
'tvn_triv2_interleave.cc',
install_rpath : ne_libdir,
install_dir : join_paths(ne_bindir, 'apptests')
)
-test('apptest_tvn_triv2_interleave', apptest_tvn_triv2_interleave, env: testenv, args: [ '10', join_paths(ne_datadir, 'testdata/TRIV240/MAX_POOL_2D_000'), join_paths(ne_datadir, 'testdata/TRIV238_2TOPS/CONV_2D_300') ], suite: ['fast-test'])
apptest_tvn_triv2_sigkill = executable ('apptest_tvn_triv2_sigkill',
'tvn_triv2_sigkill.cc',
install_rpath : ne_libdir,
install_dir : join_paths(ne_bindir, 'apptests')
)
-test('apptest_tvn_triv2_sigkill', apptest_tvn_triv2_sigkill, env: testenv, args: [ join_paths(ne_datadir, 'testdata/TRIV240/MOBILENET_V1') ], timeout : 200, suite: ['fast-test'])
-
-foreach model : models
- test('apptest_tvn_triv2_sigkill_all', apptest_tvn_triv2_sigkill, env: testenv, args: [ model ], timeout : 6000)
-endforeach
+# Test TRIV 2.3
+
+test('apptest_tvn_triv23', apptest_tvn_triv2, env: testenv, args: [ join_paths(ne_datadir, 'testdata/TRIV238_2TOPS/CONV_2D_300'), '-v', '2.3' ], timeout: 100, suite: ['fast-test'])
+test('apptest_tvn_triv23_interleave', apptest_tvn_triv2_interleave, env: testenv, args: [ '10', join_paths(ne_datadir, 'testdata/TRIV238_2TOPS/MAX_POOL_2D_000')+','+join_paths(ne_datadir, 'testdata/TRIV238_2TOPS/CONV_2D_300'), '2.3' ], suite: ['fast-test'])
+test('apptest_tvn_triv23_sigkill', apptest_tvn_triv2_sigkill, env: testenv, args: [ join_paths(ne_datadir, 'testdata/TRIV238_2TOPS/MOBILENET_V1'), '-v', '2.3' ], timeout : 200, suite: ['fast-test'])
+test('apptest_tvn_triv23_aging_0', apptest_tvn_triv2_aging, env: testenv, args: [ join_paths(ne_datadir, 'testdata/TRIV238_2TOPS/CONV_2D_300'), '1', '10', '-v', '2.3'], suite: ['fast-test'])
+test('apptest_tvn_triv23_aging_1', apptest_tvn_triv2_aging, env: testenv, args: [ join_paths(ne_datadir, 'testdata/TRIV238_2TOPS/CONV_2D_300'), '2', '10', '-v', '2.3'], suite: ['fast-test'])
+test('apptest_tvn_triv23_aging_2', apptest_tvn_triv2_aging, env: testenv, args: [ join_paths(ne_datadir, 'testdata/TRIV238_2TOPS/CONV_2D_300'), '3', '10', '-v', '2.3'], suite: ['fast-test'])
+test('apptest_tvn_triv23_aging_3', apptest_tvn_triv2_aging, env: testenv, args: [ join_paths(ne_datadir, 'testdata/TRIV238_2TOPS/CONV_2D_300'), '4', '10', '-v', '2.3'], suite: ['fast-test'])
+test('apptest_tvn_triv23_profile', apptest_tvn_triv2_profile, env: testenv, args: [ join_paths(ne_datadir, 'testdata/TRIV238_2TOPS/MOBILENET_V1'), '-p', 'visa', '-v', '2.3'], timeout: 100, suite: ['fast-test'])
+test('apptest_tvn_triv23_dmabuf', apptest_tvn_triv2_dmabuf, env: testenv, args: [ join_paths(ne_datadir, 'testdata/TRIV238_2TOPS/CONV_2D_300') , '-v', '2.3'], timeout : 100, suite: ['fast-test'])
+test('apptest_tvn_triv23_xml', apptest_tvn_triv2_xml, env: testenv, args: [join_paths(meson.source_root(), 'utils/resource/model_23.xml'), '-v', '2.3'], timeout: 100, suite: ['fast-test'])
+
+test('apptest_tvn_triv23_bulk', apptest_tvn_triv2_bulk, env: testenv, args: [ join_paths(ne_datadir, 'testdata/TRIV238_2TOPS'), '-v', '2.3' ], timeout: 2000)
+
+# Test TRIV 2.4
+
+test('apptest_tvn_triv24', apptest_tvn_triv2, env: testenv, args: [ join_paths(ne_datadir, 'testdata/TRIV242/CONV_2D_300'), '-v', '2.4' ], timeout: 100, suite: ['fast-test'])
+test('apptest_tvn_triv24_interleave', apptest_tvn_triv2_interleave, env: testenv, args: [ '10', join_paths(ne_datadir, 'testdata/TRIV242/MAX_POOL_2D_000')+','+join_paths(ne_datadir, 'testdata/TRIV242/CONV_2D_300'), '2.4' ], suite: ['fast-test'])
+test('apptest_tvn_triv24_sigkill', apptest_tvn_triv2_sigkill, env: testenv, args: [ join_paths(ne_datadir, 'testdata/TRIV242/MOBILENET_V1'), '-v', '2.4' ], timeout : 200, suite: ['fast-test'])
+test('apptest_tvn_triv24_aging_0', apptest_tvn_triv2_aging, env: testenv, args: [ join_paths(ne_datadir, 'testdata/TRIV242/CONV_2D_300'), '1', '10', '-v', '2.4'], suite: ['fast-test'])
+test('apptest_tvn_triv24_aging_1', apptest_tvn_triv2_aging, env: testenv, args: [ join_paths(ne_datadir, 'testdata/TRIV242/CONV_2D_300'), '2', '10', '-v', '2.4'], suite: ['fast-test'])
+test('apptest_tvn_triv24_aging_2', apptest_tvn_triv2_aging, env: testenv, args: [ join_paths(ne_datadir, 'testdata/TRIV242/CONV_2D_300'), '3', '10', '-v', '2.4'], suite: ['fast-test'])
+test('apptest_tvn_triv24_aging_3', apptest_tvn_triv2_aging, env: testenv, args: [ join_paths(ne_datadir, 'testdata/TRIV242/CONV_2D_300'), '4', '10', '-v', '2.4'], suite: ['fast-test'])
+test('apptest_tvn_triv24_profile', apptest_tvn_triv2_profile, env: testenv, args: [ join_paths(ne_datadir, 'testdata/TRIV242/MOBILENET_V1'), '-p', 'visa', '-v', '2.4'], timeout: 100, suite: ['fast-test'])
+test('apptest_tvn_triv24_dmabuf', apptest_tvn_triv2_dmabuf, env: testenv, args: [ join_paths(ne_datadir, 'testdata/TRIV242/CONV_2D_300'), '-v', '2.4'], timeout : 100, suite: ['fast-test'])
+test('apptest_tvn_triv24_xml', apptest_tvn_triv2_xml, env: testenv, args: [join_paths(meson.source_root(), 'utils/resource/model_24.xml'), '-v', '2.4'], timeout: 100, suite: ['fast-test'])
+
+test('apptest_tvn_triv24_bulk', apptest_tvn_triv2_bulk, env: testenv, args: [ join_paths(ne_datadir, 'testdata/TRIV242'), '-v', '2.4'], timeout: 2000)
static void
print_help (void) {
cerr << "Usage: " << __progname;
- cerr << " [# iters] [comma-seperated modelpath]\n";
+ cerr << " [# iters] [comma-seperated modelpath] [TRIV version]\n";
}
/** @brief apptest main */
unique_ptr<int[]> req_ids;
uint32_t num_models, num_iters;
- if (argc < 3) {
+ if (argc < 4) {
print_help ();
cerr << "[APPTEST] " << argv[0] << ": SKIPPED\n";
return 0;
/* perform interleaving for libnpuhost API calls */
for (int i = 0; i < num_iters; i++) {
for (int j = 0; j < num_models; j++) {
+ testers[j].setDeviceType (argv[3]);
status = testers[j].init (tops);
if (status != 0) {
cerr << "Unable to initialize\n";
install_dir : join_paths(ne_bindir, 'unittests')
)
test('unittest_ne_core_profiler', unittest_ne_core_profiler, env: testenv, suite: ['fast-test'])
+
+ unittest_ne_core_npu_emul= executable('unittest_ne_core_npu_emul',
+ ['ne_core_npu_emul_test.cc'],
+ include_directories: [ne_host_inc, ne_common_inc],
+ dependencies: [ne_test_utils_gtest_dep, ne_host_dep, ne_core_dep],
+ install : true,
+ install_rpath : ne_libdir,
+ install_dir : join_paths(ne_bindir, 'unittests')
+ )
+ test('unittest_ne_core_npu_emul', unittest_ne_core_npu_emul, env: testenv, suite: ['fast-test'])
endif
endif
const uint32_t exp_output_num_v1 = 1;
std::unique_ptr<DriverAPI> api;
- api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
ASSERT_NE (api.get (), nullptr);
std::unique_ptr<Buffer> buffer (new Buffer (new HWmemDevice));
*/
TEST (ne_core_buffer_test, buffer_create_tensors_n) {
std::unique_ptr<DriverAPI> api;
- api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
ASSERT_NE (api.get (), nullptr);
uint32_t size = 4096;
*/
TEST (ne_core_buffer_test, buffer_get_tensor_n) {
std::unique_ptr<DriverAPI> api;
- api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
ASSERT_NE (api.get (), nullptr);
std::unique_ptr<Buffer> buffer (new Buffer (new HWmemDevice));
* @brief test Device's createInstance()
*/
TEST (ne_core_handler_test, device_create_instance) {
- dev_type type = NPUCOND_TRIV2_CONN_SOCIP;
+ dev_type type = NPUCOND_TRIV24_CONN_SOCIP;
int num_devices = HostHandler::getNumDevices (type);
EXPECT_GT (num_devices, 0);
* @brief test Device's createInstance() with out-of-range id
*/
TEST (ne_core_handler_test, device_create_instance_out_of_range_n) {
- dev_type type = NPUCOND_TRIV2_CONN_SOCIP;
+ dev_type type = NPUCOND_TRIV24_CONN_SOCIP;
int num_devices = HostHandler::getNumDevices (type);
EXPECT_GT (num_devices, 0);
* @note Only createInstance() calls init().
*/
TEST (ne_core_handler_test, device_instance_uninitilized_n) {
- dev_type type = NPUCOND_TRIV2_CONN_SOCIP;
+ dev_type type = NPUCOND_TRIV24_CONN_SOCIP;
int num_devices = HostHandler::getNumDevices (type);
EXPECT_GT (num_devices, 0);
* @brief test Device's alloc/deallocMemory ()
*/
TEST (ne_core_handler_test, device_memory) {
- std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV2_CONN_SOCIP, 0));
+ std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV24_CONN_SOCIP, 0));
ASSERT_NE (device.get (), nullptr);
void *addr;
* @brief test Device's allocMemory () with error handling
*/
TEST (ne_core_handler_test, device_memory_args_n) {
- std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV2_CONN_SOCIP, 0));
+ std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV24_CONN_SOCIP, 0));
ASSERT_NE (device.get (), nullptr);
void *addr;
* @brief test TRIV2's setModel ()
*/
TEST (ne_core_handler_test, triv2_set_model) {
- std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV2_CONN_SOCIP, 0));
+ std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV24_CONN_SOCIP, 0));
ASSERT_NE (device.get (), nullptr);
generic_buffer model_buf = {};
* @brief test TRIV2's setModel () with error handling
*/
TEST (ne_core_handler_test, triv2_set_model_invalid_args_n) {
- std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV2_CONN_SOCIP, 0));
+ std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV24_CONN_SOCIP, 0));
ASSERT_NE (device.get (), nullptr);
generic_buffer model_buf = {};
* @brief test TRIV2's setModel () with error handling
*/
TEST (ne_core_handler_test, triv2_set_model_invalid_data_n) {
- std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV2_CONN_SOCIP, 0));
+ std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV24_CONN_SOCIP, 0));
ASSERT_NE (device.get (), nullptr);
generic_buffer model_buf = {};
* @brief test TRIV2's unsetModel () with error handling
*/
TEST (ne_core_handler_test, triv2_unset_model_n) {
- std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV2_CONN_SOCIP, 0));
+ std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV24_CONN_SOCIP, 0));
ASSERT_NE (device.get (), nullptr);
EXPECT_NE (device->unsetModel (nullptr), 0);
}
* @brief test Device's run ()
*/
TEST (ne_core_handler_test, triv2_run) {
- std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV2_CONN_SOCIP, 0));
+ std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV24_CONN_SOCIP, 0));
ASSERT_NE (device.get (), nullptr);
/** prepare model */
* @brief test TRIV2's run () with error handling
*/
TEST (ne_core_handler_test, triv2_run_invalid_args_n) {
- std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV2_CONN_SOCIP, 0));
+ std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV24_CONN_SOCIP, 0));
ASSERT_NE (device.get (), nullptr);
/** TRIV2 requires valid model and buffer arguments */
* @brief test TRIV2's run () with error handling
*/
TEST (ne_core_handler_test, triv2_run_invalid_opmode_n) {
- std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV2_CONN_SOCIP, 0));
+ std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV24_CONN_SOCIP, 0));
ASSERT_NE (device.get (), nullptr);
/** prepare model */
* @brief test Device's stop ()
*/
TEST (ne_core_handler_test, triv2_stop) {
- std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV2_CONN_SOCIP, 0));
+ std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV24_CONN_SOCIP, 0));
ASSERT_NE (device.get (), nullptr);
/** prepare model */
* @brief test HostHandler's registerModel ()
*/
TEST (ne_core_handler_test, handler_register_model) {
- std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV2_CONN_SOCIP, 0));
+ std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV24_CONN_SOCIP, 0));
ASSERT_NE (device.get (), nullptr);
HostHandler *handler = device->getHostHandler ();
* @brief test HostHandler's registerModel () with error handling
*/
TEST (ne_core_handler_test, handler_register_model_invalid_args_01_n) {
- std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV2_CONN_SOCIP, 0));
+ std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV24_CONN_SOCIP, 0));
ASSERT_NE (device.get (), nullptr);
HostHandler *handler = device->getHostHandler ();
* @brief test HostHandler's registerModel () with error handling
*/
TEST (ne_core_handler_test, handler_register_model_invalid_args_02_n) {
- std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV2_CONN_SOCIP, 0));
+ std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV24_CONN_SOCIP, 0));
ASSERT_NE (device.get (), nullptr);
HostHandler *handler = device->getHostHandler ();
* @brief test HostHandler's unregisterModel () with error handling
*/
TEST (ne_core_handler_test, handler_unregister_model_invalid_id_n) {
- std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV2_CONN_SOCIP, 0));
+ std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV24_CONN_SOCIP, 0));
ASSERT_NE (device.get (), nullptr);
HostHandler *handler = device->getHostHandler ();
* @brief test HostHandler's getModel () with error handling
*/
TEST (ne_core_handler_test, handler_get_model_invalid_id_n) {
- std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV2_CONN_SOCIP, 0));
+ std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV24_CONN_SOCIP, 0));
ASSERT_NE (device.get (), nullptr);
HostHandler *handler = device->getHostHandler ();
* @brief test HostHandler's setDataInfo ()
*/
TEST (ne_core_handler_test, handler_set_data_info) {
- std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV2_CONN_SOCIP, 0));
+ std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV24_CONN_SOCIP, 0));
ASSERT_NE (device.get (), nullptr);
HostHandler *handler = device->getHostHandler ();
* @brief test HostHandler's setDataInfo () with error handling
*/
TEST (ne_core_handler_test, handler_set_data_info_invalid_args_n) {
- std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV2_CONN_SOCIP, 0));
+ std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV24_CONN_SOCIP, 0));
ASSERT_NE (device.get (), nullptr);
HostHandler *handler = device->getHostHandler ();
* @brief test HostHandler's setConstraint ()
*/
TEST (ne_core_handler_test, handler_set_constraint) {
- std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV2_CONN_SOCIP, 0));
+ std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV24_CONN_SOCIP, 0));
ASSERT_NE (device.get (), nullptr);
HostHandler *handler = device->getHostHandler ();
* @brief test HostHandler's setConstraint () with error handling
*/
TEST (ne_core_handler_test, handler_set_constraint_invalid_args_n) {
- std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV2_CONN_SOCIP, 0));
+ std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV24_CONN_SOCIP, 0));
ASSERT_NE (device.get (), nullptr);
HostHandler *handler = device->getHostHandler ();
* @brief test HostHandler's allocGenericBuffer ()
*/
TEST (ne_core_handler_test, handler_generic_buffer) {
- std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV2_CONN_SOCIP, 0));
+ std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV24_CONN_SOCIP, 0));
ASSERT_NE (device.get (), nullptr);
HostHandler *handler = device->getHostHandler ();
* @brief test HostHandler's allocGenericBuffer () with error handling
*/
TEST (ne_core_handler_test, handler_generic_buffer_n) {
- std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV2_CONN_SOCIP, 0));
+ std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV24_CONN_SOCIP, 0));
ASSERT_NE (device.get (), nullptr);
HostHandler *handler = device->getHostHandler ();
* @brief test HostHandler's allocGenericBuffer () with error handling
*/
TEST (ne_core_handler_test, handler_generic_buffers_n) {
- std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV2_CONN_SOCIP, 0));
+ std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV24_CONN_SOCIP, 0));
ASSERT_NE (device.get (), nullptr);
HostHandler *handler = device->getHostHandler ();
* @brief test HostHandler's runModel (sync)
*/
TEST (ne_core_handler_test, handler_triv2_run_sync) {
- std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV2_CONN_SOCIP, 0));
+ std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV24_CONN_SOCIP, 0));
ASSERT_NE (device.get (), nullptr);
HostHandler *handler = device->getHostHandler ();
* @brief test HostHandler's runModel (sync) with error handling
*/
TEST (ne_core_handler_test, handler_triv2_run_model_n) {
- std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV2_CONN_SOCIP, 0));
+ std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV24_CONN_SOCIP, 0));
ASSERT_NE (device.get (), nullptr);
HostHandler *handler = device->getHostHandler ();
* @brief test HostHandler's runModel (async)
*/
TEST (ne_core_handler_test, handler_triv2_run_async) {
- std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV2_CONN_SOCIP, 0));
+ std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV24_CONN_SOCIP, 0));
ASSERT_NE (device.get (), nullptr);
HostHandler *handler = device->getHostHandler ();
* @brief test HostHandler's runModel (async) with error handling
*/
TEST (ne_core_handler_test, handler_triv2_run_async_n) {
- std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV2_CONN_SOCIP, 0));
+ std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV24_CONN_SOCIP, 0));
ASSERT_NE (device.get (), nullptr);
HostHandler *handler = device->getHostHandler ();
TEST (ne_core_handler_test, handler_triv2_get_memory_status) {
// disabled until this feature is implemented
#if defined(ENABLE_EMUL)
- std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV2_CONN_SOCIP, 0));
+ std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV24_CONN_SOCIP, 0));
ASSERT_NE (device.get (), nullptr);
HostHandler *handler = device->getHostHandler ();
* @brief test HostHandler's getMemoryStatus () with error handling
*/
TEST (ne_core_handler_test, handler_triv2_get_memory_status_n) {
- std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV2_CONN_SOCIP, 0));
+ std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV24_CONN_SOCIP, 0));
ASSERT_NE (device.get (), nullptr);
HostHandler *handler = device->getHostHandler ();
* @brief test HostHandler's setProfileModel () with error handling
*/
TEST (ne_core_handler_test, handler_set_profile_model_n) {
- std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV2_CONN_SOCIP, 0));
+ std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV24_CONN_SOCIP, 0));
ASSERT_NE (device.get (), nullptr);
HostHandler *handler = device->getHostHandler ();
#endif /* defined (ENABLE_EMUL) */
/** use TRIV driver api for this test */
-#define INIT_TEST_DRIVER_API() \
- ASSERT_GT (DriverAPI::getNumDevices (NPUCOND_TRIV2_CONN_SOCIP), 0); \
- std::unique_ptr<DriverAPI> api; \
- api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0); \
+#define INIT_TEST_DRIVER_API() \
+ ASSERT_GT (DriverAPI::getNumDevices (NPUCOND_TRIV24_CONN_SOCIP), 0); \
+ std::unique_ptr<DriverAPI> api; \
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0); \
EXPECT_NE (api.get (), nullptr);
#ifndef DRM_RDWR
std::unique_ptr<DriverAPI> api;
npu_input_opmode opmode = NPUINPUT_HOST;
- api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
ASSERT_NE (api.get (), nullptr);
/** create dummy model */
std::unique_ptr<DriverAPI> api;
npu_input_opmode opmode = NPUINPUT_HOST;
- api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
ASSERT_NE (api.get (), nullptr);
/** create dummy model */
std::unique_ptr<DriverAPI> api;
npu_input_opmode opmode = NPUINPUT_HW_RECURRING;
- api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
ASSERT_NE (api.get (), nullptr);
/** create dummy model */
std::unique_ptr<DriverAPI> api;
npu_input_opmode opmode = NPUINPUT_HW_RECURRING;
- api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
ASSERT_NE (api.get (), nullptr);
/** create dummy model */
*/
TEST (ne_core_inputservice_test, host_remove) {
std::unique_ptr<DriverAPI> api;
- api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
ASSERT_NE (api.get (), nullptr);
/** create dummy model */
* @brief test primitives of memory allocator default (MemDefault)
*/
TEST (ne_core_mem_test, mem_default_primitives) {
- std::unique_ptr<DriverAPI> api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ std::unique_ptr<DriverAPI> api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
ASSERT_NE (api.get (), nullptr);
/**
* @brief test primitives of memory allocator (unimplemented)
*/
TEST (ne_core_mem_test, mem_pool_primitives_n) {
- std::unique_ptr<DriverAPI> api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ std::unique_ptr<DriverAPI> api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
ASSERT_NE (api.get (), nullptr);
/** 'resv_mem_size' > 0: MemPool (not implemented yet) */
* @brief test 0 size error handling
*/
TEST (ne_core_mem_test, memory_invalid_args_n) {
- std::unique_ptr<DriverAPI> api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ std::unique_ptr<DriverAPI> api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
ASSERT_NE (api.get (), nullptr);
/**
* @brief test nullptr error handling
*/
TEST (ne_core_mem_test, alloc_no_impl_n) {
- std::unique_ptr<DriverAPI> api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ std::unique_ptr<DriverAPI> api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
ASSERT_NE (api.get (), nullptr);
/**
--- /dev/null
+/* SPDX-License-Identifier: Apache-2.0 */
+/**
+ * Copyright (C) 2023 Samsung Electronics
+ * Copyright (C) 2023 Parichay Kapoor <yelini.jeong@samsung.com>
+ */
+/**
+ * @file ne_core_npu_emul_test.cc
+ * @date 17 Mar 2023
+ * @brief Test npu driver api
+ * @author Yelin Jeong <yelini.jeong@samsung.com>
+ * @bug No known bugs except for NYI items
+ */
+
+#include <gtest/gtest.h>
+#include <NPUdrvAPI.h>
+#include <sys/mman.h>
+
+#include <future>
+#include <mutex>
+#include <thread>
+#include "typedef.h"
+
+#include <ne_test_utils_gtest.h>
+
+/** 2-TOPS TRIV2 v2.3.8 */
+#define TEST_NPU_VERSION (0x04080302)
+
+/**
+ * @brief check getNumDevices()
+ */
+TEST (ne_core_npu_emul_test, get_num_devices) {
+ int num_devices;
+
+ /** supported device types (currently) */
+ num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV23_CONN_UNKNOWN);
+ EXPECT_GT (num_devices, 0);
+ num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV23_CONN_SOCIP);
+ EXPECT_GT (num_devices, 0);
+}
+
+/**
+ * @brief check device dspm size
+ */
+TEST (ne_core_npu_emul_test, check_dev_dspm_size) {
+ int num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV23_CONN_UNKNOWN);
+ ASSERT_GT (num_devices, 0);
+ num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV23_CONN_UNKNOWN);
+ ASSERT_GT (num_devices, 0);
+
+ auto api_23 = DriverAPI::createDriverAPI (NPUCOND_TRIV23_CONN_SOCIP, 0);
+ uint32_t dspm_size;
+ EXPECT_EQ (api_23->getDspmSize (&dspm_size), 0);
+ EXPECT_EQ (dspm_size, 64 * 1024);
+}
+
+/**
+ * @brief check device statuses
+ */
+TEST (ne_core_npu_emul_test, check_dev_status_triv23) {
+ int num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV23_CONN_SOCIP);
+ ASSERT_GT (num_devices, 0);
+
+ std::unique_ptr<DriverAPI> api;
+
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV23_CONN_SOCIP, 0);
+ ASSERT_NE (api.get (), nullptr);
+ EXPECT_GE (api->getDeviceFD (), 0);
+ EXPECT_EQ (api->getDeviceID (), 0);
+ EXPECT_EQ (api->isReady (), device_state_t::TRINITY_STATE_READY);
+
+ /** open same device */
+ std::unique_ptr<DriverAPI> api2;
+ api2 = DriverAPI::createDriverAPI (NPUCOND_TRIV23_CONN_SOCIP, 0);
+ ASSERT_NE (api2.get (), nullptr);
+ EXPECT_GE (api2->getDeviceFD (), 0);
+ EXPECT_EQ (api2->getDeviceID (), 0);
+ EXPECT_EQ (api2->isReady (), device_state_t::TRINITY_STATE_READY);
+
+ EXPECT_EQ (api->getDeviceID (), api2->getDeviceID ());
+ /** file descriptors should be different */
+ EXPECT_NE (api->getDeviceFD (), api2->getDeviceFD ());
+}
+
+/**
+ * @brief check device statuses with error handling
+ */
+TEST (ne_core_npu_emul_test, check_dev_status_triv23_n) {
+ int num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV23_CONN_SOCIP);
+ ASSERT_GT (num_devices, 0);
+
+ std::unique_ptr<DriverAPI> api;
+
+ /** invalid id */
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV23_CONN_SOCIP, -1);
+ EXPECT_EQ (api.get (), nullptr);
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV23_CONN_SOCIP, num_devices);
+ EXPECT_EQ (api.get (), nullptr);
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV23_CONN_SOCIP, num_devices + 1);
+ EXPECT_EQ (api.get (), nullptr);
+}
+
+/**
+ * @brief create API instances without initailiation
+ */
+TEST (ne_core_npu_emul_test, create_instance_uninitialized_n) {
+ const size_t size = 4096;
+ model_config_t model;
+ input_config_t input;
+ size_t alloc, free;
+
+ input.task_handle = UINT32_MAX;
+
+ /** create driver APIs not using createDriverAPI() */
+ std::unique_ptr<DriverAPI> api (new TrinityVision2API (0));
+
+ api.reset (new TrinityEmulAPI (0, NPUCOND_TRIV23_CONN_SOCIP));
+
+ /** it's possible to do open() */
+ ASSERT_EQ (api->open (), 0);
+ EXPECT_NE (api->open (), 0);
+
+ /** but, not initialized */
+ EXPECT_EQ (api->isReady (), device_state_t::TRINITY_STATE_UNKNOWN);
+ EXPECT_EQ (api->alloc (size), -EPERM);
+ EXPECT_EQ (api->dealloc (0), -EPERM);
+ EXPECT_EQ (api->mmap (0, size), nullptr);
+ EXPECT_EQ (api->munmap (nullptr, size), -EPERM);
+ EXPECT_EQ (api->registerModel (&model), -EPERM);
+ EXPECT_EQ (api->deregisterModel (0), -EPERM);
+ EXPECT_EQ (api->getMemoryStatus (&alloc, &free), -EPERM);
+ EXPECT_EQ (api->runInput (&input), -EPERM);
+}
+
+/**
+ * @brief manage memory blocks using driver api
+ */
+TEST (ne_core_npu_emul_test, manage_mem_triv23) {
+ int num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV23_CONN_SOCIP);
+ ASSERT_GT (num_devices, 0);
+
+ std::unique_ptr<DriverAPI> api;
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV23_CONN_SOCIP, 0);
+ ASSERT_NE (api.get (), nullptr);
+
+ size_t size = 4096;
+ int dmabuf = api->alloc (size);
+ EXPECT_GE (dmabuf, 0);
+
+ void *ptr = api->mmap (dmabuf, size);
+ EXPECT_NE (ptr, nullptr);
+
+ for (size_t i = 0; i < size; i++)
+ static_cast<uint8_t *> (ptr)[i] = static_cast<uint8_t> (i % 256);
+
+ EXPECT_EQ (api->munmap (ptr, size), 0);
+
+ ptr = api->mmap (dmabuf, size);
+ EXPECT_NE (ptr, nullptr);
+
+ for (size_t i = 0; i < size; i++)
+ EXPECT_EQ (static_cast<uint8_t *> (ptr)[i], static_cast<uint8_t> (i % 256));
+
+ EXPECT_EQ (api->munmap (ptr, size), 0);
+ EXPECT_EQ (api->dealloc (dmabuf), 0);
+}
+
+/**
+ * @brief manage memory blocks using driver api (negative cases)
+ */
+TEST (ne_core_npu_emul_test, manage_mem_triv23_n) {
+ int num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV23_CONN_SOCIP);
+ ASSERT_GT (num_devices, 0);
+
+ std::unique_ptr<DriverAPI> api;
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV23_CONN_SOCIP, 0);
+ ASSERT_NE (api.get (), nullptr);
+
+ size_t size = 4096;
+ int dmabuf = api->alloc (size);
+ ASSERT_GE (dmabuf, 0);
+
+ /** alloc */
+ EXPECT_LT (api->alloc (0), 0);
+
+ /** mmap */
+ void *ptr;
+ ptr = api->mmap (dmabuf, 0);
+ EXPECT_EQ (ptr, nullptr);
+ ptr = api->mmap (dmabuf, size + 1);
+ EXPECT_EQ (ptr, nullptr);
+ ptr = api->mmap (dmabuf, size);
+ ASSERT_NE (ptr, nullptr);
+
+ /** munmap */
+ EXPECT_NE (api->munmap (nullptr, size), 0);
+ EXPECT_NE (api->munmap (ptr, 0), 0);
+ EXPECT_EQ (api->munmap (ptr, size), 0);
+
+ /** dealloc */
+ EXPECT_NE (api->dealloc (-1), 0);
+ EXPECT_NE (api->dealloc (dmabuf + 1), 0);
+ EXPECT_EQ (api->dealloc (dmabuf), 0);
+
+ /** mmap after dealloc */
+ ptr = api->mmap (dmabuf, size);
+ EXPECT_EQ (ptr, nullptr);
+}
+
+/**
+ * @brief set model data with error handling
+ */
+TEST (ne_core_npu_emul_test, set_model_data_n) {
+ std::unique_ptr<DriverAPI> api;
+ model_config_t model;
+ int num_devices;
+
+ /** TRIV2 Cases */
+ num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV23_CONN_SOCIP);
+ ASSERT_GT (num_devices, 0);
+
+ api.reset ();
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV23_CONN_SOCIP, 0);
+ ASSERT_NE (api.get (), nullptr);
+
+ /** invalid arguments */
+ EXPECT_NE (api->registerModel (nullptr), 0);
+
+ /** invalid model dmabuf */
+ model.dbuf_fd = -1;
+ EXPECT_NE (api->registerModel (&model), 0);
+}
+
+/**
+ * @brief set input data with error handling
+ */
+TEST (ne_core_npu_emul_test, set_input_data_n) {
+ std::unique_ptr<DriverAPI> api;
+ input_config_t input;
+ int num_devices;
+
+ input.task_handle = UINT32_MAX;
+
+ /** TRIV2 Cases */
+ num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV23_CONN_SOCIP);
+ ASSERT_GT (num_devices, 0);
+
+ api.reset ();
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV23_CONN_SOCIP, 0);
+ ASSERT_NE (api.get (), nullptr);
+
+ /** invalid arguments */
+ EXPECT_NE (api->runInput (nullptr), 0);
+
+ /** invalid buffer dmabuf */
+ input.dbuf_fd = -1;
+ EXPECT_NE (api->runInput (&input), 0);
+
+ /** still invalid model dmabuf */
+ input.dbuf_fd = api->alloc (4096);
+ ASSERT_GE (input.dbuf_fd, 0);
+ input.model_id = -1;
+ EXPECT_NE (api->runInput (&input), 0);
+}
+
+/**
+ * @brief test running inference with valid data
+ */
+TEST (ne_core_npu_emul_test, run_inference_triv23) {
+ const size_t size = 4096;
+ std::unique_ptr<DriverAPI> api;
+ model_config_t model;
+ input_config_t input;
+ int *buf;
+ int buffer_dmabuf;
+ int seg_dmabuf;
+ int model_dmabuf;
+ int num_devices;
+
+ input.task_handle = UINT32_MAX;
+
+ num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV23_CONN_SOCIP);
+ ASSERT_GT (num_devices, 0);
+
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV23_CONN_SOCIP, 0);
+ ASSERT_NE (api.get (), nullptr);
+
+ /** register model data */
+ model_dmabuf = api->alloc (size);
+ EXPECT_GE (model_dmabuf, 0);
+
+ model.version = 3;
+ model.dbuf_fd = model_dmabuf;
+ model.program_offset_addr = 0;
+ model.program_size = 0;
+ model.metadata_dbuf_fd = model_dmabuf; /* dummy */
+
+ EXPECT_EQ (api->registerModel (&model, TEST_NPU_VERSION), 0);
+
+ /** allocate input data */
+ buffer_dmabuf = api->alloc (size);
+ EXPECT_GE (buffer_dmabuf, 0);
+
+ /** configure segment table */
+ buf = (int *) api->mmap (buffer_dmabuf, size);
+ memset (buf, 0, size);
+ seg_dmabuf = api->alloc (size);
+ buf[0] = seg_dmabuf;
+
+ /** run with this model */
+ input.dbuf_fd = buffer_dmabuf;
+ input.model_id = model.id;
+ input.num_segments = 1;
+ input.input_mode = TRINITY_INPUT_CPU;
+ input.output_mode = TRINITY_OUTPUT_CPU_INTR;
+ input.timeout_ms = 100;
+
+ EXPECT_GE (api->runInput (&input), 0);
+ EXPECT_EQ (api->munmap (buf, size), 0);
+ EXPECT_EQ (api->deregisterModel (model.id), 0);
+ EXPECT_EQ (api->dealloc (model_dmabuf), 0);
+ EXPECT_EQ (api->dealloc (buffer_dmabuf), 0);
+}
+
+/**
+ * @brief A test for running inference with a valid model allocated from a
+ * separate thread
+ */
+TEST (ne_core_npu_emul_test, run_inference_async0_triv23) {
+ const size_t size = 4096;
+ std::unique_ptr<DriverAPI> api;
+ model_config_t model;
+ std::future<int> f_ret;
+ input_config_t input;
+ int seg_dmabuf;
+ int model_dmabuf;
+ int num_devices;
+
+ input.task_handle = UINT32_MAX;
+
+ num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV23_CONN_SOCIP);
+ ASSERT_GT (num_devices, 0);
+
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV23_CONN_SOCIP, 0);
+ ASSERT_NE (api.get (), nullptr);
+
+ /** register model data */
+ model_dmabuf = api->alloc (size);
+ EXPECT_GE (model_dmabuf, 0);
+
+ model.version = 3;
+ model.dbuf_fd = model_dmabuf;
+ model.program_offset_addr = 0;
+ model.program_size = 0;
+ model.metadata_dbuf_fd = model_dmabuf; /* dummy */
+
+ EXPECT_EQ (api->registerModel (&model, TEST_NPU_VERSION), 0);
+
+ int *buf = nullptr;
+ int buffer_dmabuf = -1;
+
+ f_ret = std::async (std::launch::async, [&]() -> int {
+ /** allocate input data */
+ buffer_dmabuf = api->alloc (size);
+ if (buffer_dmabuf < 0)
+ return -ENOMEM;
+
+ /** configure segment table */
+ buf = (int *) api->mmap (buffer_dmabuf, size);
+ memset (buf, 0, size);
+ seg_dmabuf = api->alloc (size);
+ if (seg_dmabuf < 0)
+ return -ENOMEM;
+ buf[0] = seg_dmabuf;
+
+ /** run with this model */
+ input.dbuf_fd = buffer_dmabuf;
+ input.model_id = model.id;
+ input.num_segments = 1;
+ input.input_mode = TRINITY_INPUT_CPU;
+ input.output_mode = TRINITY_OUTPUT_CPU_INTR;
+ input.timeout_ms = 100;
+
+ return api->runInput (&input);
+ });
+
+ EXPECT_GE (f_ret.get (), 0);
+ EXPECT_EQ (api->munmap (buf, size), 0);
+ EXPECT_EQ (api->deregisterModel (model.id), 0);
+ EXPECT_EQ (api->dealloc (model_dmabuf), 0);
+ EXPECT_EQ (api->dealloc (buffer_dmabuf), 0);
+}
+
+/**
+ * @brief A test for running inference using async thread with a valid model
+ */
+TEST (ne_core_npu_emul_test, run_inference_async1_triv23) {
+ const size_t size = 4096;
+ std::unique_ptr<DriverAPI> api;
+ std::future<model_config_t> f_model;
+ model_config_t model;
+ input_config_t input;
+ int *buf;
+ int buffer_dmabuf;
+ int seg_dmabuf;
+ int num_devices;
+
+ input.task_handle = UINT32_MAX;
+
+ num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV23_CONN_SOCIP);
+ ASSERT_GT (num_devices, 0);
+
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV23_CONN_SOCIP, 0);
+ ASSERT_NE (api.get (), nullptr);
+
+ f_model = std::async (std::launch::async, [&]() -> model_config_t {
+ int ret;
+ model_config_t model = {};
+
+ /** register model data */
+ ret = api->alloc (size);
+ model.dbuf_fd = ret;
+ if (ret < 0)
+ return model;
+
+ model.version = 3;
+ model.program_offset_addr = 0;
+ model.program_size = 0;
+ model.metadata_dbuf_fd = ret; /* dummy */
+
+ ret = api->registerModel (&model, TEST_NPU_VERSION);
+ if (ret < 0) {
+ model.dbuf_fd = -1;
+ }
+
+ return model;
+ });
+
+ /** allocate input data */
+ buffer_dmabuf = api->alloc (size);
+ ASSERT_GE (buffer_dmabuf, 0);
+
+ /** configure segment table */
+ buf = (int *) api->mmap (buffer_dmabuf, size);
+ memset (buf, 0, size);
+ seg_dmabuf = api->alloc (size);
+ ASSERT_GE (seg_dmabuf, 0);
+ buf[0] = seg_dmabuf;
+
+ /** run with this model */
+ input.dbuf_fd = buffer_dmabuf;
+ model = f_model.get ();
+
+ ASSERT_GE (model.dbuf_fd, 0);
+ input.model_id = model.id;
+ input.num_segments = 1;
+ input.input_mode = TRINITY_INPUT_CPU;
+ input.output_mode = TRINITY_OUTPUT_CPU_INTR;
+ input.timeout_ms = 100;
+
+ EXPECT_GE (api->runInput (&input), 0);
+ EXPECT_EQ (api->munmap (buf, size), 0);
+ EXPECT_EQ (api->deregisterModel (model.id), 0);
+ EXPECT_EQ (api->dealloc (model.dbuf_fd), 0);
+ EXPECT_EQ (api->dealloc (buffer_dmabuf), 0);
+}
+
+/**
+ * @brief test running inference with invalid segment table
+ */
+TEST (ne_core_npu_emul_test, run_inference_triv23_n) {
+ const size_t size = 8192;
+ std::unique_ptr<DriverAPI> api;
+ model_config_t model;
+ input_config_t input;
+ int buffer_dmabuf;
+ int model_dmabuf;
+ int num_devices;
+
+ input.task_handle = UINT32_MAX;
+
+ num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV23_CONN_SOCIP);
+ ASSERT_GT (num_devices, 0);
+
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV23_CONN_SOCIP, 0);
+ ASSERT_NE (api.get (), nullptr);
+
+ /** register model data */
+ model_dmabuf = api->alloc (size);
+ EXPECT_GE (model_dmabuf, 0);
+
+ model.version = 3;
+ model.dbuf_fd = model_dmabuf;
+ model.program_offset_addr = 0;
+ model.program_size = 4096;
+ model.metadata_dbuf_fd = model_dmabuf; /* dummy */
+
+ EXPECT_EQ (api->registerModel (&model, TEST_NPU_VERSION), 0);
+
+ /** allocate input data */
+ buffer_dmabuf = api->alloc (size);
+ EXPECT_GE (buffer_dmabuf, 0);
+
+ /** run with this model */
+ input.dbuf_fd = buffer_dmabuf;
+ input.model_id = model.id;
+ /** failure case: segments information is not properly set */
+ input.num_segments = 0;
+ input.input_mode = TRINITY_INPUT_CPU;
+ input.output_mode = TRINITY_OUTPUT_CPU_INTR;
+ input.timeout_ms = 100;
+
+ EXPECT_EQ (api->runInput (&input), -EINVAL);
+ EXPECT_EQ (api->deregisterModel (model.id), 0);
+ EXPECT_EQ (api->dealloc (model_dmabuf), 0);
+ EXPECT_EQ (api->dealloc (buffer_dmabuf), 0);
+}
+
+/**
+ * @brief main function for unit test
+ */
+int
+main (int argc, char **argv) {
+ return start_gtest (argc, argv);
+}
int num_devices;
/** supported device types (currently) */
- num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV2_CONN_UNKNOWN);
+ num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV24_CONN_UNKNOWN);
EXPECT_GT (num_devices, 0);
- num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV2_CONN_SOCIP);
+ num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV24_CONN_SOCIP);
EXPECT_GT (num_devices, 0);
}
num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV24_CONN_UNKNOWN);
ASSERT_GT (num_devices, 0);
- auto api_23 = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
- uint32_t dspm_size;
- EXPECT_EQ (api_23->getDspmSize (&dspm_size), 0);
- EXPECT_EQ (dspm_size, 64 * 1024);
-
auto api_24 = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
+ uint32_t dspm_size;
EXPECT_EQ (api_24->getDspmSize (&dspm_size), 0);
EXPECT_EQ (dspm_size, 192 * 1024);
}
/**
* @brief check device statuses
*/
-TEST (ne_core_npu_test, check_dev_status_triv2) {
- int num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV2_CONN_SOCIP);
+TEST (ne_core_npu_test, check_dev_status_triv24) {
+ int num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV24_CONN_SOCIP);
ASSERT_GT (num_devices, 0);
std::unique_ptr<DriverAPI> api;
- api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
ASSERT_NE (api.get (), nullptr);
EXPECT_GE (api->getDeviceFD (), 0);
EXPECT_EQ (api->getDeviceID (), 0);
/** open same device */
std::unique_ptr<DriverAPI> api2;
- api2 = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ api2 = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
ASSERT_NE (api2.get (), nullptr);
EXPECT_GE (api2->getDeviceFD (), 0);
EXPECT_EQ (api2->getDeviceID (), 0);
/**
* @brief check device statuses with error handling
*/
-TEST (ne_core_npu_test, check_dev_status_triv2_n) {
- int num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV2_CONN_SOCIP);
+TEST (ne_core_npu_test, check_dev_status_triv24_n) {
+ int num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV24_CONN_SOCIP);
ASSERT_GT (num_devices, 0);
std::unique_ptr<DriverAPI> api;
/** invalid id */
- api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, -1);
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, -1);
EXPECT_EQ (api.get (), nullptr);
- api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, num_devices);
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, num_devices);
EXPECT_EQ (api.get (), nullptr);
- api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, num_devices + 1);
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, num_devices + 1);
EXPECT_EQ (api.get (), nullptr);
}
EXPECT_EQ (api->runInput (&input), -EPERM);
#ifdef ENABLE_EMUL
- api.reset (new TrinityEmulAPI (0, NPUCOND_TRIV2_CONN_SOCIP));
+ api.reset (new TrinityEmulAPI (0, NPUCOND_TRIV24_CONN_SOCIP));
/** it's possible to do open() */
ASSERT_EQ (api->open (), 0);
/**
* @brief manage memory blocks using driver api
*/
-TEST (ne_core_npu_test, manage_mem_triv2) {
- int num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV2_CONN_SOCIP);
+TEST (ne_core_npu_test, manage_mem_triv24) {
+ int num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV24_CONN_SOCIP);
ASSERT_GT (num_devices, 0);
std::unique_ptr<DriverAPI> api;
- api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
ASSERT_NE (api.get (), nullptr);
size_t size = 4096;
/**
* @brief manage memory blocks using driver api (negative cases)
*/
-TEST (ne_core_npu_test, manage_mem_triv2_n) {
- int num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV2_CONN_SOCIP);
+TEST (ne_core_npu_test, manage_mem_triv24_n) {
+ int num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV24_CONN_SOCIP);
ASSERT_GT (num_devices, 0);
std::unique_ptr<DriverAPI> api;
- api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
ASSERT_NE (api.get (), nullptr);
size_t size = 4096;
int num_devices;
/** TRIV2 Cases */
- num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV2_CONN_SOCIP);
+ num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV24_CONN_SOCIP);
ASSERT_GT (num_devices, 0);
api.reset ();
- api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
ASSERT_NE (api.get (), nullptr);
/** invalid arguments */
input.task_handle = UINT32_MAX;
/** TRIV2 Cases */
- num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV2_CONN_SOCIP);
+ num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV24_CONN_SOCIP);
ASSERT_GT (num_devices, 0);
api.reset ();
- api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
ASSERT_NE (api.get (), nullptr);
/** invalid arguments */
/**
* @brief test running inference with valid data
*/
-TEST (ne_core_npu_test, run_inference_triv2) {
+TEST (ne_core_npu_test, run_inference_triv24) {
const size_t size = 4096;
std::unique_ptr<DriverAPI> api;
model_config_t model;
* @brief A test for running inference with a valid model allocated from a
* separate thread
*/
-TEST (ne_core_npu_test, run_inference_async0_triv2) {
+TEST (ne_core_npu_test, run_inference_async0_triv24) {
const size_t size = 4096;
std::unique_ptr<DriverAPI> api;
model_config_t model;
/**
* @brief A test for running inference using async thread with a valid model
*/
-TEST (ne_core_npu_test, run_inference_async1_triv2) {
+TEST (ne_core_npu_test, run_inference_async1_triv24) {
const size_t size = 4096;
std::unique_ptr<DriverAPI> api;
std::future<model_config_t> f_model;
/**
* @brief test running inference with invalid segment table
*/
-TEST (ne_core_npu_test, run_inference_triv2_n) {
+TEST (ne_core_npu_test, run_inference_triv24_n) {
const size_t size = 8192;
std::unique_ptr<DriverAPI> api;
model_config_t model;
TEST (ne_core_profiler_test, merge_profile) {
const npu_profile_opt opt_visa = {.level = PROFILE_LEVEL_VISA};
- int ret, num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV2_CONN_SOCIP);
+ int ret, num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV24_CONN_SOCIP);
ASSERT_GT (num_devices, 0);
- auto api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ auto api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
ASSERT_NE (api.get (), nullptr);
std::unique_ptr<ModelProfiler> profiler (new ModelProfiler (api.get ()));
const npu_profile_opt opt_dlp = {.level = PROFILE_LEVEL_VISA_DLP};
const npu_profile_opt opt_visa = {.level = PROFILE_LEVEL_VISA};
- int ret, num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV2_CONN_SOCIP);
+ int ret, num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV24_CONN_SOCIP);
ASSERT_GT (num_devices, 0);
- auto api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ auto api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
ASSERT_NE (api.get (), nullptr);
std::unique_ptr<ModelProfiler> profiler (new ModelProfiler (api.get ()));
TEST (ne_core_profiler_test, profile_TRIV23) {
const npu_profile_opt opt_visa = {.level = PROFILE_LEVEL_VISA};
- int ret, num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV2_CONN_SOCIP);
+ int ret, num_devices = DriverAPI::getNumDevices (NPUCOND_TRIV23_CONN_SOCIP);
ASSERT_GT (num_devices, 0);
- auto api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ auto api = DriverAPI::createDriverAPI (NPUCOND_TRIV23_CONN_SOCIP, 0);
ASSERT_NE (api.get (), nullptr);
std::unique_ptr<ModelProfiler> profiler (new ModelProfiler (api.get ()));
*/
TEST (ne_core_sched_test, request_set_get_primitives) {
std::unique_ptr<DriverAPI> api;
- api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
ASSERT_NE (api.get (), nullptr);
/** create dummy model */
*/
TEST (ne_core_sched_test, request_set_get_args_n) {
std::unique_ptr<DriverAPI> api;
- api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
ASSERT_NE (api.get (), nullptr);
bool force_stop = false;
*/
TEST (ne_core_sched_test, submit_request) {
std::unique_ptr<DriverAPI> api;
- api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
ASSERT_NE (api.get (), nullptr);
/** create dummy model */
*/
TEST (ne_core_sched_test, submit_request_args_n) {
std::unique_ptr<DriverAPI> api;
- api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
ASSERT_NE (api.get (), nullptr);
/** create dummy model */
*/
TEST (ne_core_sched_test, submit_request_opmode_n) {
std::unique_ptr<DriverAPI> api;
- api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
ASSERT_NE (api.get (), nullptr);
/** create dummy model */
*/
TEST (ne_core_sched_test, submit_request_empty_n) {
std::unique_ptr<DriverAPI> api;
- api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
ASSERT_NE (api.get (), nullptr);
std::unique_ptr<Scheduler> sched (new Scheduler (api.get ()));
*/
TEST (ne_core_segment_table_test, create_segments) {
std::unique_ptr<DriverAPI> api;
- api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
ASSERT_NE (api.get (), nullptr);
std::unique_ptr<Model> model (new Model (new HWmemDevice));
*/
TEST (ne_core_segment_table_test, primitives_n) {
std::unique_ptr<DriverAPI> api;
- api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
ASSERT_NE (api.get (), nullptr);
std::unique_ptr<Model> model (new Model (new HWmemDevice));
*/
TEST (ne_core_segment_table_test, create_segments_n) {
std::unique_ptr<DriverAPI> api;
- api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
+ api = DriverAPI::createDriverAPI (NPUCOND_TRIV24_CONN_SOCIP, 0);
ASSERT_NE (api.get (), nullptr);
std::unique_ptr<Model> model (new Model (new HWmemDevice));
#include <ne_test_utils.h>
#include <ne_test_utils_gtest.h>
-#define BASIC_TEST_MODEL NE_DATADIR "/testdata/TRIV240/CONV_2D_000"
+#define BASIC_TEST_MODEL NE_DATADIR "/testdata/TRIV242/CONV_2D_000"
/**
* @brief test primitives supported in libnpuhost
std::cerr << "Unknown profile level: " << level << std::endl;
}
}
+
+/** @brief set profile level */
+void
+UtilTrinity::setDeviceType (const std::string type) {
+ if (type == "2.3")
+ type_ = NPUCOND_TRIV23_CONN_SOCIP;
+ else if (type == "2.4")
+ type_ = NPUCOND_TRIV24_CONN_SOCIP;
+ else {
+ std::cerr << "Unknown device type: " << type << std::endl;
+ }
+}
+
/** @brief parse/set arguments and get working directory */
int
UtilTrinity::parseArgs (int argc, char **argv, const char *param_str, int *index) {
optind = 0;
opterr = 0;
- while ((c = getopt (argc, argv, "d:n:p:tmsho")) != -1) {
+ while ((c = getopt (argc, argv, "v:d:n:p:tmsho")) != -1) {
switch (c) {
case 'd':
setNodePath (optarg);
case 'p':
setProfLevel (optarg);
break;
+ case 'v':
+ setDeviceType (optarg);
+ break;
case 't':
setTrinityFormat ();
break;
setDump ();
break;
case '?':
- if (optopt == 'd' || optopt == 'n' || optopt == 'p')
- std::cerr << "Option 'd', 'n', or 'p' requires an extra argument";
+ if (optopt == 'd' || optopt == 'n' || optopt == 'p' || optopt == 'v')
+ std::cerr << "Option 'd', 'n', 'p' of 'v' requires an extra argument";
else
std::cerr << "Unknown flag: " << c;
std::cerr << std::endl;
void setNotiMode (const std::string mode);
void setNodePath (const std::string node);
void setProfLevel (const std::string level);
+ void setDeviceType (const std::string type);
int getTops (std::string model_dir);
int init (uint32_t tops = default_tops);
--- /dev/null
+<testcases>
+ <model name="mobilenet_v1" timeout="3000" priority="1">
+ <dirpath>/opt/trinity/share/npu-engine/testdata/TRIV238_2TOPS/MOBILENET_V1</dirpath>
+ </model>
+ <model name="mobilenet_v2" timeout="1000" priority="2">
+ <dirpath>/opt/trinity/share/npu-engine/testdata/TRIV238_2TOPS/MOBILENET_V2</dirpath>
+ </model>
+</testcases>
--- /dev/null
+<testcases>
+ <model name="mobilenet_v1" timeout="3000" priority="1">
+ <dirpath>/opt/trinity/share/npu-engine/testdata/TRIV242/MOBILENET_V1</dirpath>
+ </model>
+ <model name="mobilenet_v2" timeout="1000" priority="2">
+ <dirpath>/opt/trinity/share/npu-engine/testdata/TRIV242/MOBILENET_V2</dirpath>
+ </model>
+</testcases>
projects / platform / adaptation / npu / trix-engine.git / commitdiff