# Set firmware version
add_definitions( -DFIRMWARE_VERSION_MAJOR=4 )
add_definitions( -DFIRMWARE_VERSION_MINOR=16 )
-add_definitions( -DFIRMWARE_VERSION_REVISION=1 )
+add_definitions( -DFIRMWARE_VERSION_REVISION=2 )
if(HAILO_BUILD_SERVICE)
add_definitions( -DHAILO_SUPPORT_MULTI_PROCESS )
endif()
set(HAILORT_MAJOR_VERSION 4)
set(HAILORT_MINOR_VERSION 16)
-set(HAILORT_REVISION_VERSION 1)
+set(HAILORT_REVISION_VERSION 2)
# Add the cmake folder so the modules there are found
set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
message(FATAL_ERROR "Only unix hosts are supported, stopping build")
endif()
-find_package(HailoRT 4.16.1 EXACT REQUIRED)
+find_package(HailoRT 4.16.2 EXACT REQUIRED)
# GST_PLUGIN_DEFINE needs PACKAGE to be defined
set(GST_HAILO_PACKAGE_NAME "hailo")
PROP_INPUT_FROM_META,
PROP_NO_TRANSFORM,
PROP_MULTI_PROCESS_SERVICE,
+ PROP_PASS_THROUGH,
// Deprecated
PROP_VDEVICE_KEY,
buffer = static_cast<GstBuffer*>(gst_queue_array_pop_head(self->thread_queue));
self->buffers_in_thread_queue--;
}
+ self->thread_cv.notify_all();
if (GST_IS_PAD(self->srcpad)) { // Checking because we fail here when exiting the application
GstFlowReturn ret = gst_pad_push(self->srcpad, buffer);
if ((GST_FLOW_OK != ret) && (GST_FLOW_FLUSHING != ret) && (!self->has_got_eos)) {
case PROP_IS_ACTIVE:
(void)gst_hailonet2_toggle_activation(self, self->props.m_is_active.get(), g_value_get_boolean(value));
break;
+ case PROP_PASS_THROUGH:
+ self->props.m_pass_through = g_value_get_boolean(value);
+ break;
case PROP_OUTPUTS_MIN_POOL_SIZE:
if (self->is_configured) {
- g_warning("The network was already configured so changing the outputs minimum pool size will not take place!");
+ g_warning("The network has already been configured, the output's minimum pool size cannot be changed!");
break;
}
self->props.m_outputs_min_pool_size = g_value_get_uint(value);
case PROP_IS_ACTIVE:
g_value_set_boolean(value, self->props.m_is_active.get());
break;
+ case PROP_PASS_THROUGH:
+ g_value_set_boolean(value, self->props.m_pass_through.get());
+ break;
case PROP_OUTPUTS_MIN_POOL_SIZE:
g_value_set_uint(value, self->props.m_outputs_min_pool_size.get());
break;
"By default, the hailonet element will not be active unless it is the only one. "
"Setting this property in combination with 'scheduling-algorithm' different than HAILO_SCHEDULING_ALGORITHM_NONE is not supported.", false,
(GParamFlags)(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
+ g_object_class_install_property(gobject_class, PROP_PASS_THROUGH,
+ g_param_spec_boolean("pass-through", "Is Element pass-through", "Controls whether the element will perform inference or simply pass buffers through. "
+ "By default, the hailonet element will not be pass-through. "
+ "Setting this property to true disables inference, regardless of the scheduler settings.", false,
+ (GParamFlags)(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property(gobject_class, PROP_SCHEDULING_ALGORITHM,
g_param_spec_enum("scheduling-algorithm", "Scheduling policy for automatic network group switching", "Controls the Model Scheduler algorithm of HailoRT. "
{
{
std::unique_lock<std::mutex> lock(self->thread_queue_mutex);
+ self->thread_cv.wait(lock, [self] () {
+ return self->buffers_in_thread_queue < self->props.m_outputs_max_pool_size.get();
+ });
gst_queue_array_push_tail(self->thread_queue, buffer);
self->buffers_in_thread_queue++;
}
GstHailoNet2 *self = GST_HAILONET2(parent);
std::unique_lock<std::mutex> lock(self->infer_mutex);
- if (!self->props.m_is_active.get() || (nullptr == self->configured_infer_model)) {
+ if (self->props.m_pass_through.get() || !self->props.m_is_active.get()) {
gst_hailonet2_push_buffer_to_thread(self, buffer);
return GST_FLOW_OK;
}
{
public:
HailoNet2Properties() : m_hef_path(nullptr), m_batch_size(HAILO_DEFAULT_BATCH_SIZE),
- m_device_id(nullptr), m_device_count(0), m_vdevice_group_id(nullptr), m_is_active(false),
+ m_device_id(nullptr), m_device_count(0), m_vdevice_group_id(nullptr), m_is_active(false), m_pass_through(false),
m_outputs_min_pool_size(MIN_OUTPUTS_POOL_SIZE), m_outputs_max_pool_size(MAX_OUTPUTS_POOL_SIZE),
m_scheduling_algorithm(HAILO_SCHEDULING_ALGORITHM_ROUND_ROBIN), m_scheduler_timeout_ms(HAILO_DEFAULT_SCHEDULER_TIMEOUT_MS),
m_scheduler_threshold(HAILO_DEFAULT_SCHEDULER_THRESHOLD), m_scheduler_priority(HAILO_SCHEDULER_PRIORITY_NORMAL),
HailoElemProperty<guint16> m_device_count;
HailoElemProperty<gchar*> m_vdevice_group_id;
HailoElemProperty<gboolean> m_is_active;
+ HailoElemProperty<gboolean> m_pass_through;
HailoElemProperty<guint> m_outputs_min_pool_size;
HailoElemProperty<guint> m_outputs_max_pool_size;
HailoElemProperty<hailo_scheduling_algorithm_t> m_scheduling_algorithm;
SUPPORTED_PROTOCOL_VERSION = 2
SUPPORTED_FW_MAJOR = 4
SUPPORTED_FW_MINOR = 16
-SUPPORTED_FW_REVISION = 1
+SUPPORTED_FW_REVISION = 2
MEGA_MULTIPLIER = 1000.0 * 1000.0
"linux_aarch64",
],
url="https://hailo.ai/",
- version="4.16.1",
+ version="4.16.2",
zip_safe=False,
)
# VISIBILITY_INLINES_HIDDEN YES
)
-find_package(HailoRT 4.16.1 EXACT REQUIRED)
+find_package(HailoRT 4.16.2 EXACT REQUIRED)
target_link_libraries(_pyhailort PRIVATE HailoRT::libhailort)
if(WIN32)
set(THREADS_PREFER_PTHREAD_FLAG ON)
find_package(Threads REQUIRED)
-find_package(HailoRT 4.16.1 EXACT REQUIRED)
+find_package(HailoRT 4.16.2 EXACT REQUIRED)
SET_SOURCE_FILES_PROPERTIES(data_quantization_example.c PROPERTIES LANGUAGE C)
set(THREADS_PREFER_PTHREAD_FLAG ON)
find_package(Threads REQUIRED)
-find_package(HailoRT 4.16.1 EXACT REQUIRED)
+find_package(HailoRT 4.16.2 EXACT REQUIRED)
SET_SOURCE_FILES_PROPERTIES(infer_pipeline_example.c PROPERTIES LANGUAGE C)
set(THREADS_PREFER_PTHREAD_FLAG ON)
find_package(Threads REQUIRED)
-find_package(HailoRT 4.16.1 EXACT REQUIRED)
+find_package(HailoRT 4.16.2 EXACT REQUIRED)
SET_SOURCE_FILES_PROPERTIES(multi_device_example.c PROPERTIES LANGUAGE C)
find_package(Threads REQUIRED)
set(THREADS_PREFER_PTHREAD_FLAG ON)
-find_package(HailoRT 4.16.1 EXACT REQUIRED)
+find_package(HailoRT 4.16.2 EXACT REQUIRED)
SET_SOURCE_FILES_PROPERTIES(multi_network_vstream_example.c PROPERTIES LANGUAGE C)
set(THREADS_PREFER_PTHREAD_FLAG ON)
find_package(Threads REQUIRED)
-find_package(HailoRT 4.16.1 EXACT REQUIRED)
+find_package(HailoRT 4.16.2 EXACT REQUIRED)
SET_SOURCE_FILES_PROPERTIES(notification_callback_example.c PROPERTIES LANGUAGE C)
cmake_minimum_required(VERSION 3.0.0)
-find_package(HailoRT 4.16.1 EXACT REQUIRED)
+find_package(HailoRT 4.16.2 EXACT REQUIRED)
SET_SOURCE_FILES_PROPERTIES(power_measurement_example.c PROPERTIES LANGUAGE C)
cmake_minimum_required(VERSION 3.0.0)
-find_package(HailoRT 4.16.1 EXACT REQUIRED)
+find_package(HailoRT 4.16.2 EXACT REQUIRED)
SET_SOURCE_FILES_PROPERTIES(raw_async_streams_single_thread_example.c PROPERTIES LANGUAGE C)
set(THREADS_PREFER_PTHREAD_FLAG ON)
find_package(Threads REQUIRED)
-find_package(HailoRT 4.16.1 EXACT REQUIRED)
+find_package(HailoRT 4.16.2 EXACT REQUIRED)
SET_SOURCE_FILES_PROPERTIES(raw_streams_example.c PROPERTIES LANGUAGE C)
set(THREADS_PREFER_PTHREAD_FLAG ON)
find_package(Threads REQUIRED)
-find_package(HailoRT 4.16.1 EXACT REQUIRED)
+find_package(HailoRT 4.16.2 EXACT REQUIRED)
SET_SOURCE_FILES_PROPERTIES(switch_network_groups_example.c PROPERTIES LANGUAGE C)
set(THREADS_PREFER_PTHREAD_FLAG ON)
find_package(Threads REQUIRED)
-find_package(HailoRT 4.16.1 EXACT REQUIRED)
+find_package(HailoRT 4.16.2 EXACT REQUIRED)
SET_SOURCE_FILES_PROPERTIES(switch_network_groups_manually_example.c PROPERTIES LANGUAGE C)
set(THREADS_PREFER_PTHREAD_FLAG ON)
find_package(Threads REQUIRED)
-find_package(HailoRT 4.16.1 EXACT REQUIRED)
+find_package(HailoRT 4.16.2 EXACT REQUIRED)
SET_SOURCE_FILES_PROPERTIES(vstreams_example.c PROPERTIES LANGUAGE C)
cmake_minimum_required(VERSION 3.0.0)
-find_package(HailoRT 4.16.1 EXACT REQUIRED)
+find_package(HailoRT 4.16.2 EXACT REQUIRED)
add_executable(cpp_async_infer_example async_infer_example.cpp)
target_link_libraries(cpp_async_infer_example PRIVATE HailoRT::libhailort)
cmake_minimum_required(VERSION 3.0.0)
-find_package(HailoRT 4.16.1 EXACT REQUIRED)
+find_package(HailoRT 4.16.2 EXACT REQUIRED)
add_executable(cpp_async_infer_functionality_example async_infer_functionality_example.cpp)
target_link_libraries(cpp_async_infer_functionality_example PRIVATE HailoRT::libhailort)
cmake_minimum_required(VERSION 3.0.0)
-find_package(HailoRT 4.16.1 EXACT REQUIRED)
+find_package(HailoRT 4.16.2 EXACT REQUIRED)
add_executable(cpp_infer_pipeline_example infer_pipeline_example.cpp)
target_link_libraries(cpp_infer_pipeline_example PRIVATE HailoRT::libhailort)
set(THREADS_PREFER_PTHREAD_FLAG ON)
find_package(Threads REQUIRED)
-find_package(HailoRT 4.16.1 EXACT REQUIRED)
+find_package(HailoRT 4.16.2 EXACT REQUIRED)
add_executable(cpp_multi_device_example multi_device_example.cpp)
target_link_libraries(cpp_multi_device_example PRIVATE HailoRT::libhailort Threads::Threads)
find_package(Threads REQUIRED)
set(THREADS_PREFER_PTHREAD_FLAG ON)
-find_package(HailoRT 4.16.1 EXACT REQUIRED)
+find_package(HailoRT 4.16.2 EXACT REQUIRED)
add_executable(cpp_multi_network_vstream_example multi_network_vstream_example.cpp)
target_link_libraries(cpp_multi_network_vstream_example PRIVATE HailoRT::libhailort Threads::Threads)
set(THREADS_PREFER_PTHREAD_FLAG ON)
find_package(Threads REQUIRED)
-find_package(HailoRT 4.16.1 EXACT REQUIRED)
+find_package(HailoRT 4.16.2 EXACT REQUIRED)
add_executable(cpp_multi_process_example multi_process_example.cpp)
target_link_libraries(cpp_multi_process_example PRIVATE HailoRT::libhailort Threads::Threads)
cmake_minimum_required(VERSION 3.0.0)
-find_package(HailoRT 4.16.1 EXACT REQUIRED)
+find_package(HailoRT 4.16.2 EXACT REQUIRED)
add_executable(cpp_notification_callback_example notification_callback_example.cpp)
target_link_libraries(cpp_notification_callback_example PRIVATE HailoRT::libhailort)
cmake_minimum_required(VERSION 3.0.0)
-find_package(HailoRT 4.16.1 EXACT REQUIRED)
+find_package(HailoRT 4.16.2 EXACT REQUIRED)
add_executable(cpp_power_measurement_example power_measurement_example.cpp)
target_link_libraries(cpp_power_measurement_example PRIVATE HailoRT::libhailort)
set(THREADS_PREFER_PTHREAD_FLAG ON)
find_package(Threads REQUIRED)
-find_package(HailoRT 4.16.1 EXACT REQUIRED)
+find_package(HailoRT 4.16.2 EXACT REQUIRED)
add_executable(cpp_raw_async_streams_multi_thread_example raw_async_streams_multi_thread_example.cpp)
target_link_libraries(cpp_raw_async_streams_multi_thread_example PRIVATE HailoRT::libhailort Threads::Threads)
set(THREADS_PREFER_PTHREAD_FLAG ON)
find_package(Threads REQUIRED)
-find_package(HailoRT 4.16.1 EXACT REQUIRED)
+find_package(HailoRT 4.16.2 EXACT REQUIRED)
add_executable(cpp_raw_async_streams_single_thread_example raw_async_streams_single_thread_example.cpp)
target_link_libraries(cpp_raw_async_streams_single_thread_example PRIVATE HailoRT::libhailort Threads::Threads)
set(THREADS_PREFER_PTHREAD_FLAG ON)
find_package(Threads REQUIRED)
-find_package(HailoRT 4.16.1 EXACT REQUIRED)
+find_package(HailoRT 4.16.2 EXACT REQUIRED)
add_executable(cpp_raw_streams_example raw_streams_example.cpp)
target_link_libraries(cpp_raw_streams_example PRIVATE HailoRT::libhailort Threads::Threads)
set(THREADS_PREFER_PTHREAD_FLAG ON)
find_package(Threads REQUIRED)
-find_package(HailoRT 4.16.1 EXACT REQUIRED)
+find_package(HailoRT 4.16.2 EXACT REQUIRED)
add_executable(cpp_switch_network_groups_example switch_network_groups_example.cpp)
target_link_libraries(cpp_switch_network_groups_example PRIVATE HailoRT::libhailort Threads::Threads)
find_package(Threads REQUIRED)
set(THREADS_PREFER_PTHREAD_FLAG ON)
-find_package(HailoRT 4.16.1 EXACT REQUIRED)
+find_package(HailoRT 4.16.2 EXACT REQUIRED)
add_executable(cpp_switch_network_groups_manually_example switch_network_groups_manually_example.cpp)
target_link_libraries(cpp_switch_network_groups_manually_example PRIVATE HailoRT::libhailort Threads::Threads)
set(THREADS_PREFER_PTHREAD_FLAG ON)
find_package(Threads REQUIRED)
-find_package(HailoRT 4.16.1 EXACT REQUIRED)
+find_package(HailoRT 4.16.2 EXACT REQUIRED)
add_executable(cpp_vstreams_example vstreams_example.cpp)
target_link_libraries(cpp_vstreams_example PRIVATE HailoRT::libhailort Threads::Threads)
board_info.device_architecture = static_cast<hailo_device_architecture_t>(BYTE_ORDER__ntohl(identify_response->device_architecture));
+ // Device architecture can be HAILO_ARCH_HAILO15H or HAILO_ARCH_HAILO15M - but the FW will always return HAILO_ARCH_HAILO15H
+ // Based on a file the SCU gives us we can deduce the actual type
+ if (HAILO_ARCH_HAILO15H == board_info.device_architecture) {
+ auto dev_arch_exp = PartialClusterReader::get_actual_dev_arch_from_fuse(board_info.device_architecture);
+ CHECK_EXPECTED(dev_arch_exp);
+ board_info.device_architecture = dev_arch_exp.release();
+ }
+
/* Write identify results to log */
LOGGER__INFO("firmware_version is: {}.{}.{}",
board_info.fw_version.major,
return std::stoi(std::string(force_layout_env));
}
- auto device_arch_exp = device.get_architecture();
- CHECK_EXPECTED(device_arch_exp);
- if (HAILO_ARCH_HAILO8L != device_arch_exp.value() && HAILO_ARCH_HAILO15M != device_arch_exp.value()) {
+ auto dev_arch_exp = device.get_architecture();
+ CHECK_EXPECTED(dev_arch_exp);
+ const auto dev_arch = dev_arch_exp.release();
+ // In Both cases of Hailo15H and Hailo15M read fuse file (If no file found will return default value of all clusters)
+ if ((HAILO_ARCH_HAILO15H == dev_arch) || (HAILO_ARCH_HAILO15M == dev_arch)) {
+ auto bitmap_exp = PartialClusterReader::get_partial_clusters_layout_bitmap(dev_arch);
+ CHECK_EXPECTED(bitmap_exp);
+ const auto bitmap = bitmap_exp.release();
+ if (PARTIAL_CLUSTERS_LAYOUT_BITMAP__HAILO15_DEFAULT == bitmap) {
+ return Expected<uint32_t>(PARTIAL_CLUSTERS_LAYOUT_IGNORE);
+ } else {
+ return Expected<uint32_t>(bitmap);
+ }
+ } else if (HAILO_ARCH_HAILO8L != dev_arch) {
// Partial clusters layout is only relevant in HAILO_ARCH_HAILO8L and HAILO_ARCH_HAILO15M arch
return Expected<uint32_t>(PARTIAL_CLUSTERS_LAYOUT_IGNORE);
- }
-
- if (HAILO_ARCH_HAILO15M == device_arch_exp.value()) {
- return PartialClusterReader::get_partial_clusters_layout_bitmap(device_arch_exp.value());
} else {
auto extended_device_info_response = get_extended_device_info_response(device);
CHECK_EXPECTED(extended_device_info_response);
**/
#include "hailo/hailort_common.hpp"
-
+#include "common/filesystem.hpp"
#include "partial_cluster_reader.hpp"
#include <fstream>
namespace hailort
{
-Expected<uint32_t> PartialClusterReader::get_arch_default_bitmap(const hailo_device_architecture_t dev_arch)
+// SKU is three bit value in fuse file in order to differentiate the different kind of boards
+#define SKU_VALUE_BITMAP (0x7)
+#define HAILO15H_SKU_VALUE (0x0)
+#define HAILO15M_SKU_VALUE (0x3)
+
+// SKU and partial cluster layout bitmap are located at specific locations in the fuse file according to the spec
+// Located in issue HRT-12971
+#define SKU_BYTE_INDEX_IN_FUSE_FILE (32)
+#define SKU_BIT_INDEX_IN_WORD (18)
+#define ACTIVE_CLUSTER_LAYOUT_BITMAP_INDEX_IN_FUSE_FILE (80)
+
+Expected<uint32_t> PartialClusterReader::get_arch_default_bitmap(hailo_device_architecture_t dev_arch)
{
switch(dev_arch) {
- // Currently only supported architecture for this function is HAILO15M - but in future can add more
+ // Currently only supported architectures for this function are HAILO15H and HAILO15M - but in future can add
+ case HAILO_ARCH_HAILO15H:
case HAILO_ARCH_HAILO15M:
- return static_cast<uint32_t>(PARTIAL_CLUSTERS_LAYOUT_BITMAP__HAILO15M_DEFAULT);
+ return static_cast<uint32_t>(PARTIAL_CLUSTERS_LAYOUT_BITMAP__HAILO15_DEFAULT);
default:
LOGGER__ERROR("Error, Given architecture {} doesnt support partial cluster layout",
HailoRTCommon::get_device_arch_str(dev_arch));
}
}
-bool PartialClusterReader::validate_arch_partial_clusters_bitmap(const hailo_device_architecture_t dev_arch,
- const uint32_t bitmap)
+bool PartialClusterReader::validate_arch_partial_clusters_bitmap(uint32_t bitmap, uint8_t sku_value)
{
- switch(dev_arch) {
- // Currently only supported architecture for this function is HAILO15M - but in future can add more
- case HAILO_ARCH_HAILO15M:
+ // Currently only supported architectures for this function are HAILO15H and HAILO15M - but in future can add
+ switch (sku_value) {
+ case HAILO15H_SKU_VALUE:
+ return (PARTIAL_CLUSTERS_LAYOUT_BITMAP__HAILO15_DEFAULT == bitmap);
+ case HAILO15M_SKU_VALUE:
return (std::find(HAILO15M__PARTIAL_CLUSTERS_LAYOUT_BITMAP_ARRAY.begin(),
HAILO15M__PARTIAL_CLUSTERS_LAYOUT_BITMAP_ARRAY.end(), bitmap) !=
HAILO15M__PARTIAL_CLUSTERS_LAYOUT_BITMAP_ARRAY.end());
default:
- LOGGER__ERROR("Error, Given architecture {} doesnt support partial cluster layout",
- HailoRTCommon::get_device_arch_str(dev_arch));
return false;
}
}
-Expected<uint32_t> PartialClusterReader::get_partial_clusters_layout_bitmap(const hailo_device_architecture_t dev_arch)
+// NOTE: This Function assumes fuse file exists - and file not being able to be opened is considered error
+Expected<std::pair<uint32_t, uint8_t>> PartialClusterReader::read_fuse_file()
{
std::ifstream layout_bitmap_file;
layout_bitmap_file.open(PARTIAL_CLUSTER_READER_CLUSTER_LAYOUT_FILE_PATH, std::ios::binary);
- if (!layout_bitmap_file.is_open()) {
- LOGGER__WARNING("partial cluster layout bitmap file not found, Enabling all clusters by default");
- return get_arch_default_bitmap(dev_arch);
- }
+
+ CHECK_AS_EXPECTED(layout_bitmap_file.is_open(), HAILO_OPEN_FILE_FAILURE, "Failed Opening layout bitmap file {}",
+ PARTIAL_CLUSTER_READER_CLUSTER_LAYOUT_FILE_PATH);
+
+ // SKU is located at SKU_BYTE_INDEX_IN_FUSE_FILE
+ layout_bitmap_file.seekg(SKU_BYTE_INDEX_IN_FUSE_FILE, std::ios::beg);
+ CHECK_AS_EXPECTED(layout_bitmap_file.good(), HAILO_FILE_OPERATION_FAILURE, "Failed seek in fuse file");
+
+ // Read SKU value from file as well to validate arch type
+ uint32_t misc_word = 0;
+ layout_bitmap_file.read(reinterpret_cast<char*>(&misc_word), sizeof(misc_word));
+ CHECK_AS_EXPECTED(layout_bitmap_file.good(), HAILO_FILE_OPERATION_FAILURE, "Failed reading fuse file");
+ uint8_t sku_value = ((misc_word >> SKU_BIT_INDEX_IN_WORD) & SKU_VALUE_BITMAP);
+
+ // active clusters bitmap is located at ACTIVE_CLUSTER_LAYOUT_BITMAP_INDEX_IN_FUSE_FILE
+ layout_bitmap_file.seekg(ACTIVE_CLUSTER_LAYOUT_BITMAP_INDEX_IN_FUSE_FILE, std::ios::beg);
+ CHECK_AS_EXPECTED(layout_bitmap_file.good(), HAILO_FILE_OPERATION_FAILURE, "Failed seek in fuse file");
uint32_t partial_clusters_layout_bitmap = 0;
layout_bitmap_file.read(reinterpret_cast<char*>(&partial_clusters_layout_bitmap),
sizeof(partial_clusters_layout_bitmap));
+ CHECK_AS_EXPECTED(layout_bitmap_file.good(), HAILO_FILE_OPERATION_FAILURE, "Failed reading fuse file");
- // Fuse file represents clusters that are enabled with 0 in bit value and clusters that are disabled with 1
- // We also ignore all the MSB's that dont represent clusters.
- // Therefore, after reading the uint32 layout - we mask with the default bitmap and bitwise flip the
- // relevant bits so that 1 will represent enabled clusters
- const auto arch_bitmap_mask_exp = get_arch_default_bitmap(dev_arch);
- CHECK_EXPECTED(arch_bitmap_mask_exp);
- partial_clusters_layout_bitmap = (~partial_clusters_layout_bitmap & arch_bitmap_mask_exp.value());
layout_bitmap_file.close();
- CHECK_AS_EXPECTED(validate_arch_partial_clusters_bitmap(dev_arch, partial_clusters_layout_bitmap),
- HAILO_INTERNAL_FAILURE, "Error, Invalid partial clusters bitmap value given {}",
+ CHECK_AS_EXPECTED(validate_arch_partial_clusters_bitmap(partial_clusters_layout_bitmap, sku_value),
+ HAILO_INTERNAL_FAILURE, "Error, Given SKU value {} doesnt support partial cluster layout {}", sku_value,
partial_clusters_layout_bitmap);
- return partial_clusters_layout_bitmap;
+ return std::make_pair(partial_clusters_layout_bitmap, static_cast<uint8_t>(sku_value));
+}
+
+Expected<uint8_t> PartialClusterReader::get_sku_value_from_arch(hailo_device_architecture_t dev_arch)
+{
+ switch(dev_arch) {
+ // Currently only supported architectures for this function are HAILO15H and HAILO15M - but in future can add
+ case HAILO_ARCH_HAILO15H:
+ return HAILO15H_SKU_VALUE;
+ case HAILO_ARCH_HAILO15M:
+ return HAILO15M_SKU_VALUE;
+ default:
+ LOGGER__ERROR("Error, Unknown sku value for Given architecture {}",
+ HailoRTCommon::get_device_arch_str(dev_arch));
+ return make_unexpected(HAILO_INTERNAL_FAILURE);
+ }
+}
+
+Expected<uint32_t> PartialClusterReader::get_partial_clusters_layout_bitmap(hailo_device_architecture_t dev_arch)
+{
+ std::pair<uint32_t, uint8_t> fuse_file_data;
+
+ // If file does not exist - get default values for dev_arch
+ if (!Filesystem::does_file_exists(std::string(PARTIAL_CLUSTER_READER_CLUSTER_LAYOUT_FILE_PATH))) {
+ LOGGER__INFO("partial cluster layout bitmap file not found, Enabling all clusters by default");
+ auto default_bitmap_exp = get_arch_default_bitmap(dev_arch);
+ CHECK_EXPECTED(default_bitmap_exp);
+ fuse_file_data.first = default_bitmap_exp.release();
+
+ auto sku_value_exp = get_sku_value_from_arch(dev_arch);
+ CHECK_EXPECTED(sku_value_exp);
+ fuse_file_data.second = sku_value_exp.release();
+ } else {
+ // This will read bitmap and verify with SKU value
+ auto fuse_file_exp = read_fuse_file();
+ CHECK_EXPECTED(fuse_file_exp);
+ fuse_file_data = fuse_file_exp.release();
+ }
+
+ const auto sku_value = fuse_file_data.second;
+ switch (dev_arch) {
+ case HAILO_ARCH_HAILO15H:
+ CHECK_AS_EXPECTED((HAILO15H_SKU_VALUE == sku_value), HAILO_INTERNAL_FAILURE,
+ "Device arch is of type {} but sku is {}", dev_arch, sku_value);
+ break;
+ case HAILO_ARCH_HAILO15M:
+ CHECK_AS_EXPECTED((HAILO15M_SKU_VALUE == sku_value), HAILO_INTERNAL_FAILURE,
+ "Device arch is of type {} but sku is {}", dev_arch, sku_value);
+ break;
+ default:
+ LOGGER__ERROR("Error, Device architecture {} doesnt support partial cluster layout", dev_arch);
+ return make_unexpected(HAILO_INTERNAL_FAILURE);
+ }
+
+ return Expected<uint32_t>(fuse_file_data.first);
+}
+
+Expected<hailo_device_architecture_t> PartialClusterReader::get_actual_dev_arch_from_fuse(hailo_device_architecture_t fw_dev_arch)
+{
+ // If fuse file does not exist - and fw_dev_arch is HAILO_ARCH_HAILO15H - then it is HAILO_ARCH_HAILO15H
+ if (!Filesystem::does_file_exists(std::string(PARTIAL_CLUSTER_READER_CLUSTER_LAYOUT_FILE_PATH))
+ && (HAILO_ARCH_HAILO15H == fw_dev_arch)) {
+ return HAILO_ARCH_HAILO15H;
+ } else {
+ auto fuse_file_exp = read_fuse_file();
+ CHECK_EXPECTED(fuse_file_exp);
+ const auto fuse_file_data = fuse_file_exp.release();
+
+ const auto sku_value = fuse_file_data.second;
+ if (HAILO15M_SKU_VALUE == sku_value) {
+ return HAILO_ARCH_HAILO15M;
+ } else if (HAILO15H_SKU_VALUE == sku_value) {
+ return HAILO_ARCH_HAILO15H;
+ } else {
+ LOGGER__ERROR("Error, Invalid sku received {}", sku_value);
+ return make_unexpected(HAILO_INVALID_ARGUMENT);
+ }
+ }
}
} /* namespace hailort */
#define PARTIAL_CLUSTERS_LAYOUT_BITMAP__HAILO15M_0 ((0x1 << 1) | (0x1 << 2) | (0x1 << 3))
#define PARTIAL_CLUSTERS_LAYOUT_BITMAP__HAILO15M_1 ((0x1 << 0) | (0x1 << 2) | (0x1 << 3))
#define PARTIAL_CLUSTERS_LAYOUT_BITMAP__HAILO15M_2 ((0x1 << 0) | (0x1 << 1) | (0x1 << 4))
+
+#define HAILO15M_PARTIAL_CLUSTER_LAYOUTS_LIST PARTIAL_CLUSTERS_LAYOUT_BITMAP__HAILO15M_0,\
+ PARTIAL_CLUSTERS_LAYOUT_BITMAP__HAILO15M_1, PARTIAL_CLUSTERS_LAYOUT_BITMAP__HAILO15M_2
+
// Default is all clusters are enabled
-#define PARTIAL_CLUSTERS_LAYOUT_BITMAP__HAILO15M_DEFAULT ((0x1 << 0) | (0x1 << 1) | (0x1 << 2) | (0x1 << 3) | (0x1 << 4))
+#define PARTIAL_CLUSTERS_LAYOUT_BITMAP__HAILO15_DEFAULT ((0x1 << 0) | (0x1 << 1) | (0x1 << 2) | (0x1 << 3) | (0x1 << 4))
-constexpr const char* PARTIAL_CLUSTER_READER_CLUSTER_LAYOUT_FILE_PATH = "/sys/devices/platform/fuse";
+constexpr const char* PARTIAL_CLUSTER_READER_CLUSTER_LAYOUT_FILE_PATH = "/sys/devices/soc0/fuse";
// Array that has all the valid layouts for Hailo15M
-static constexpr std::array<uint32_t, 4> HAILO15M__PARTIAL_CLUSTERS_LAYOUT_BITMAP_ARRAY = {
- PARTIAL_CLUSTERS_LAYOUT_BITMAP__HAILO15M_0, PARTIAL_CLUSTERS_LAYOUT_BITMAP__HAILO15M_1,
- PARTIAL_CLUSTERS_LAYOUT_BITMAP__HAILO15M_2, PARTIAL_CLUSTERS_LAYOUT_BITMAP__HAILO15M_DEFAULT
+static constexpr std::array<uint32_t, 3> HAILO15M__PARTIAL_CLUSTERS_LAYOUT_BITMAP_ARRAY = {
+ HAILO15M_PARTIAL_CLUSTER_LAYOUTS_LIST
+};
+
+// Array that has all the valid layouts for Hailo15 (Either Hailo15M or Hailo15H)
+static constexpr std::array<uint32_t, 4> HAILO15__PARTIAL_CLUSTERS_LAYOUT_BITMAP_ARRAY = {
+ HAILO15M_PARTIAL_CLUSTER_LAYOUTS_LIST, PARTIAL_CLUSTERS_LAYOUT_BITMAP__HAILO15_DEFAULT
};
class PartialClusterReader {
public:
- static Expected<uint32_t> get_partial_clusters_layout_bitmap(const hailo_device_architecture_t dev_arch);
+ static Expected<uint32_t> get_partial_clusters_layout_bitmap(hailo_device_architecture_t dev_arch);
+ static Expected<hailo_device_architecture_t> get_actual_dev_arch_from_fuse(hailo_device_architecture_t fw_dev_arch);
private:
- static Expected<uint32_t> get_arch_default_bitmap(const hailo_device_architecture_t dev_arch);
- static bool validate_arch_partial_clusters_bitmap(const hailo_device_architecture_t dev_arch, const uint32_t bitmap);
+ static Expected<uint32_t> get_arch_default_bitmap(hailo_device_architecture_t dev_arch);
+ static Expected<uint8_t> get_sku_value_from_arch(hailo_device_architecture_t dev_arch);
+ static bool validate_arch_partial_clusters_bitmap(uint32_t bitmap, uint8_t sku_value);
+ static Expected<std::pair<uint32_t, uint8_t>> read_fuse_file();
};
@ECHO OFF
set BASE_URI=https://hailo-hailort.s3.eu-west-2.amazonaws.com
-set HRT_VERSION=4.16.1
+set HRT_VERSION=4.16.2
set FW_DIR=Hailo8/%HRT_VERSION%/FW
set FW=hailo8_fw.%HRT_VERSION%_eth.bin
set -e
readonly BASE_URI="https://hailo-hailort.s3.eu-west-2.amazonaws.com"
-readonly HRT_VERSION=4.16.1
+readonly HRT_VERSION=4.16.2
readonly FW_AWS_DIR="Hailo8/${HRT_VERSION}/FW"
readonly FW="hailo8_fw.${HRT_VERSION}_eth.bin"
:: cmd
@ECHO OFF
set BASE_URI=https://hailo-hailort.s3.eu-west-2.amazonaws.com
-set HRT_VERSION=4.16.1
+set HRT_VERSION=4.16.2
set REMOTE_HEF_DIR=Hailo8/%HRT_VERSION%/HEFS
set LOCAL_EXAMPLES_HEF_DIR=..\libhailort\examples\hefs
set LOCAL_TUTORIALS_HEF_DIR=..\libhailort\bindings\python\platform\hailo_tutorials\hefs
set -e
readonly BASE_URI="https://hailo-hailort.s3.eu-west-2.amazonaws.com"
-readonly HRT_VERSION=4.16.1
+readonly HRT_VERSION=4.16.2
readonly REMOTE_HEF_DIR="Hailo8/${HRT_VERSION}/HEFS"
readonly LOCAL_EXAMPLES_HEF_DIR="../libhailort/examples/hefs"
readonly LOCAL_TUTORIALS_HEF_DIR="../libhailort/bindings/python/platform/hailo_tutorials/hefs"
projects / platform / upstream / hailort.git / commitdiff