static void
add_hierarchy_to_namelist (char *path, dev_t device)
{
char *buffer = get_directory_contents (path, device);
{
struct name *name;
for (name = name_list_head; name; name = name->next)
if (strcmp (name->name, path) == 0)
break;
if (name)
name->dir_contents = buffer ? buffer : "\0\0\0\0";
}
if (buffer)
{
size_t name_length = strlen (path);
size_t allocated_length = (name_length >= NAME_FIELD_SIZE
? name_length + NAME_FIELD_SIZE
: NAME_FIELD_SIZE);
char *name_buffer = xmalloc (allocated_length + 1);
/* FIXME: + 2 above? */
char *string;
size_t string_length;
strcpy (name_buffer, path);
if (name_buffer[name_length - 1] != '/')
{
name_buffer[name_length++] = '/';
name_buffer[name_length] = '\0';
}
for (string = buffer; *string; string += string_length + 1)
{
string_length = strlen (string);
if (*string == 'D')
{
if (name_length + string_length >= allocated_length)
{
while (name_length + string_length >= allocated_length)
allocated_length += NAME_FIELD_SIZE;
name_buffer = (char *)
xrealloc (name_buffer, allocated_length + 1);
}
strcpy (name_buffer + name_length, string + 1);
add_name (name_buffer);
add_hierarchy_to_namelist (name_buffer, device);
}
}
free (name_buffer);
}
}
int main(int argc, char *argv[])
{
try {
if (argc <= 1) {
const std::string path(argv[0]);
std::cout << "usage: " << path.substr(path.find_last_of("/\\") + 1) <<
R"_help_( <parameters> input_dir
<parameters> include:
--device=<name>
name of dynamic library (without suffix) with computational device
to be used for demo
--batch=<value>
size of group of images that are classified together; large batch
sizes have better performance
--model=<name>
name of network model that is used for classification
can be caffenet_float or caffenet_int16
--input=<directory>
path to directory that contains images to be classified
--config=<name>
file name of config file containing additional parameters
command line parameters take priority over config ones
If last parameters do not fit --key=value format it is assumed to be a --input.
Instead of "--" "-" or "/" can be used.
)_help_";
return 0;
}
// convert argc/argv to vector of arguments
std::vector<std::string> arg;
for(int n=1; n<argc; ++n) arg.push_back(argv[n]);
// parse configuration (command line and from file)
using config_t = std::map<std::string, std::string>;
config_t config;
parse_parameters(config, arg);
{ // find if config file name was given from command line
config_t::iterator it;
if((it = config.find("config"))!=std::end(config)){
std::ifstream config_file(it->second);
std::vector<std::string> config_lines;
using istream_it = std::istream_iterator<std::string>;
std::copy(istream_it(config_file), istream_it(), std::back_inserter(config_lines));
parse_parameters(config, config_lines);
}
}
{ // validate & add default value for missing arguments
auto not_found = std::end(config);
if(config.find("device")==not_found) config["device"]="device_cpu";
if(config.find("batch") ==not_found) config["batch"]="48";
if(config.find("model") ==not_found) config["model"]="caffenet_float";
if(config.find("input") ==not_found) throw std::runtime_error("missing input directory; run without arguments to get help");
if(config.find("loops") ==not_found) config["loops"]="1";
}
// load images from input directory
auto images_list = get_directory_contents(config["input"]);
if(images_list.empty()) throw std::runtime_error(std::string("directory ")+config["input"]+" does not contain any images that can be processed");
// RAII for loading library and device initialization
scoped_library library(config["device"]+dynamic_library_extension);
scoped_device_0 device(library);
auto workload = primitives_workload::instance().get(config["model"]);
const int config_batch = std::stoi(config["batch"]);
if(config_batch<=0) throw std::runtime_error("batch_size is 0 or negative");
workload->init(device.primitives, device.device, config_batch);
C_time_control timer;
timer.tock();
std::cout
<< "Workload initialized at "
<< timer.time_diff_string() <<" [" <<timer.clocks_diff_string() <<"]"
<< std::endl
<< "--------------------------------------------------------"
<< std::endl;
auto absolute_output_cmpl = new nn::data<float, 2>(1000, config_batch);
std::vector<std::string> batch_images;
uint16_t image_counter = 0; //numbering images within single batch
bool start_batch = false;
const std::string path(argv[0]);
std::string appname(path.substr(path.find_last_of("/\\") + 1));
C_report_maker report(appname,library.name, config["model"], config_batch);
std::cout << "Now, please wait. I try to recognize " << images_list.size() << " images" << std::endl;
auto images_list_iterator = images_list.begin();
auto images_list_end = images_list.end();
while(images_list_iterator!=images_list_end) {
auto diff_itr = images_list_end - images_list_iterator < config_batch
? images_list_end - images_list_iterator
: config_batch;
std::vector<std::string> batch_images(images_list_iterator,images_list_iterator+diff_itr);
images_list_iterator+=diff_itr;
nn::data<float,4> *images = nullptr;
images = nn_data_load_from_image_list(&batch_images,
workload->get_img_size(),
workload->image_process,
config_batch,
workload->RGB_order);
if(images) {
images_recognition_batch_t temp_report_recognition_batch;
{
NN_API_STATUS status;
C_time_control timer;
auto loops = std::stoi(config["loops"]);
for(size_t i=0; i <loops; ++i)
{
workload->execute(*images,*absolute_output_cmpl);
}
timer.tock();
temp_report_recognition_batch.time_of_recognizing = timer.get_time_diff()/loops;
temp_report_recognition_batch.clocks_of_recognizing = timer.get_clocks_diff()/loops;
}
delete images;
float* value_cmpl = reinterpret_cast<float*>(absolute_output_cmpl->buffer);
auto batch_images_iterator = batch_images.begin();
for(auto b = 0u; (b < config_batch) && (b < batch_images.size()); ++b) {
image_recognition_item_t temp_report_recognition_item;
recognition_state_t temp_recognition_state;
std::map <float,int> output_values;
temp_report_recognition_item.recognitions.clear();
temp_report_recognition_item.recognized_image = *batch_images_iterator++;
for(int index = 0; index < 1000; ++index) {
output_values.insert(std::make_pair(value_cmpl[index],index));
temp_report_recognition_item.nnet_output.push_back(value_cmpl[index]);
}
temp_report_recognition_item.wwid = temp_report_recognition_item.recognized_image.find('[') != std::string::npos
? temp_report_recognition_item.recognized_image.substr(temp_report_recognition_item.recognized_image.find('[') + 1,9)
: "n000000000";
auto iterator = --output_values.end();
for(int i = 1; i < 6 && iterator != output_values.end(); i++)
{
temp_recognition_state.label = workload->labels[iterator->second];
temp_recognition_state.wwid = workload->wwids[iterator->second];
temp_recognition_state.accuracy = iterator->first;
temp_report_recognition_item.recognitions.push_back(temp_recognition_state);
--iterator;
}
temp_report_recognition_batch.recognized_images.push_back(temp_report_recognition_item);
output_values.clear();
value_cmpl += 1000;
}
batch_images.clear();
report.recognized_batches.push_back(temp_report_recognition_batch);
temp_report_recognition_batch.recognized_images.clear();
}
}
std::string html_filename="result_"+get_timestamp()+".html";
report.print_to_html_file(html_filename, "Results of recognition");
system((show_HTML_command+html_filename).c_str());
return 0;
}
void
diff_archive (void)
{
struct stat stat_data;
int name_length;
int status;
errno = EPIPE; /* FIXME: errno should be read-only */
/* FIXME: remove perrors */
set_next_block_after (current_header);
decode_header (current_header, ¤t_stat, ¤t_format, 1);
/* Print the block from `current_header' and `current_stat'. */
if (verbose_option)
{
if (now_verifying)
fprintf (stdlis, _("Verify "));
print_header ();
}
switch (current_header->header.typeflag)
{
default:
WARN ((0, 0, _("Unknown file type '%c' for %s, diffed as normal file"),
current_header->header.typeflag, current_file_name));
/* Fall through. */
case AREGTYPE:
case REGTYPE:
case GNUTYPE_SPARSE:
case CONTTYPE:
/* Appears to be a file. See if it's really a directory. */
name_length = strlen (current_file_name) - 1;
if (current_file_name[name_length] == PATHSEP)
goto really_dir;
if (!get_stat_data (&stat_data))
{
if (current_header->oldgnu_header.isextended)
skip_extended_headers ();
skip_file ((long) current_stat.st_size);
goto quit;
}
if (!S_ISREG (stat_data.st_mode))
{
report_difference (_("Not a regular file"));
skip_file ((long) current_stat.st_size);
goto quit;
}
stat_data.st_mode &= 07777;
if (stat_data.st_mode != current_stat.st_mode)
report_difference (_("Mode differs"));
#if !MSDOS && !WIN32
/* stat() in djgpp's C library gives a constant number of 42 as the
uid and gid of a file. So, comparing an FTP'ed archive just after
unpack would fail on MSDOS. */
if (stat_data.st_uid != current_stat.st_uid)
report_difference (_("Uid differs"));
if (stat_data.st_gid != current_stat.st_gid)
report_difference (_("Gid differs"));
#endif
if (stat_data.st_mtime != current_stat.st_mtime)
report_difference (_("Mod time differs"));
if (current_header->header.typeflag != GNUTYPE_SPARSE &&
stat_data.st_size != current_stat.st_size)
{
report_difference (_("Size differs"));
skip_file ((long) current_stat.st_size);
goto quit;
}
diff_handle = open (current_file_name, O_NDELAY | O_RDONLY | O_BINARY);
if (diff_handle < 0 && !absolute_names_option)
{
char *tmpbuf = xmalloc (strlen (current_file_name) + 2);
*tmpbuf = PATHSEP;
strcpy (tmpbuf + 1, current_file_name);
diff_handle = open (tmpbuf, O_NDELAY | O_RDONLY);
free (tmpbuf);
}
if (diff_handle < 0)
{
ERROR ((0, errno, _("Cannot open %s"), current_file_name));
if (current_header->oldgnu_header.isextended)
skip_extended_headers ();
skip_file ((long) current_stat.st_size);
report_difference (NULL);
goto quit;
}
/* Need to treat sparse files completely differently here. */
if (current_header->header.typeflag == GNUTYPE_SPARSE)
diff_sparse_files (current_stat.st_size);
else
{
if (multi_volume_option)
{
assign_string (&save_name, current_file_name);
save_totsize = current_stat.st_size;
/* save_sizeleft is set in read_and_process. */
}
read_and_process ((long) (current_stat.st_size), process_rawdata);
if (multi_volume_option)
assign_string (&save_name, NULL);
}
status = close (diff_handle);
if (status < 0)
ERROR ((0, errno, _("Error while closing %s"), current_file_name));
quit:
break;
#if !MSDOS
case LNKTYPE:
{
dev_t dev;
ino_t ino;
if (!get_stat_data (&stat_data))
break;
dev = stat_data.st_dev;
ino = stat_data.st_ino;
status = stat (current_link_name, &stat_data);
if (status < 0)
{
if (errno == ENOENT)
report_difference (_("Does not exist"));
else
{
WARN ((0, errno, _("Cannot stat file %s"), current_file_name));
report_difference (NULL);
}
break;
}
if (stat_data.st_dev != dev || stat_data.st_ino != ino)
{
char *message = (char *)
xmalloc (MESSAGE_BUFFER_SIZE + strlen (current_link_name));
sprintf (message, _("Not linked to %s"), current_link_name);
report_difference (message);
free (message);
break;
}
break;
}
#endif /* not MSDOS */
#ifdef S_ISLNK
case SYMTYPE:
{
char linkbuf[NAME_FIELD_SIZE + 3]; /* FIXME: may be too short. */
status = readlink (current_file_name, linkbuf, (sizeof linkbuf) - 1);
if (status < 0)
{
if (errno == ENOENT)
report_difference (_("No such file or directory"));
else
{
WARN ((0, errno, _("Cannot read link %s"), current_file_name));
report_difference (NULL);
}
break;
}
linkbuf[status] = '\0'; /* null-terminate it */
if (strncmp (current_link_name, linkbuf, (size_t) status) != 0)
report_difference (_("Symlink differs"));
break;
}
#endif /* not S_ISLNK */
#ifdef S_IFCHR
case CHRTYPE:
current_stat.st_mode |= S_IFCHR;
goto check_node;
#endif /* not S_IFCHR */
#ifdef S_IFBLK
/* If local system doesn't support block devices, use default case. */
case BLKTYPE:
current_stat.st_mode |= S_IFBLK;
goto check_node;
#endif /* not S_IFBLK */
#ifdef S_ISFIFO
/* If local system doesn't support FIFOs, use default case. */
case FIFOTYPE:
# ifdef S_IFIFO
current_stat.st_mode |= S_IFIFO;
# endif
current_stat.st_rdev = 0; /* FIXME: do we need this? */
goto check_node;
#endif /* S_ISFIFO */
check_node:
/* FIXME: deal with umask. */
if (!get_stat_data (&stat_data))
break;
if (current_stat.st_rdev != stat_data.st_rdev)
{
report_difference (_("Device numbers changed"));
break;
}
if (
#ifdef S_IFMT
current_stat.st_mode != stat_data.st_mode
#else
/* POSIX lossage. */
(current_stat.st_mode & 07777) != (stat_data.st_mode & 07777)
#endif
)
{
report_difference (_("Mode or device-type changed"));
break;
}
break;
case GNUTYPE_DUMPDIR:
{
char *dumpdir_buffer = get_directory_contents (current_file_name, 0);
if (multi_volume_option)
{
assign_string (&save_name, current_file_name);
save_totsize = current_stat.st_size;
/* save_sizeleft is set in read_and_process. */
}
if (dumpdir_buffer)
{
dumpdir_cursor = dumpdir_buffer;
read_and_process ((long) (current_stat.st_size), process_dumpdir);
free (dumpdir_buffer);
}
else
read_and_process ((long) (current_stat.st_size), process_noop);
if (multi_volume_option)
assign_string (&save_name, NULL);
/* Fall through. */
}
case DIRTYPE:
/* Check for trailing /. */
name_length = strlen (current_file_name) - 1;
really_dir:
while (name_length && current_file_name[name_length] == PATHSEP)
current_file_name[name_length--] = '\0'; /* zap / */
if (!get_stat_data (&stat_data))
break;
if (!S_ISDIR (stat_data.st_mode))
{
report_difference (_("No longer a directory"));
break;
}
if ((stat_data.st_mode & 07777) != (current_stat.st_mode & 07777))
report_difference (_("Mode differs"));
break;
case GNUTYPE_VOLHDR:
break;
case GNUTYPE_MULTIVOL:
{
off_t offset;
name_length = strlen (current_file_name) - 1;
if (current_file_name[name_length] == PATHSEP)
goto really_dir;
if (!get_stat_data (&stat_data))
break;
if (!S_ISREG (stat_data.st_mode))
{
report_difference (_("Not a regular file"));
skip_file ((long) current_stat.st_size);
break;
}
stat_data.st_mode &= 07777;
offset = from_oct (1 + 12, current_header->oldgnu_header.offset);
if (stat_data.st_size != current_stat.st_size + offset)
{
report_difference (_("Size differs"));
skip_file ((long) current_stat.st_size);
break;
}
diff_handle = open (current_file_name, O_NDELAY | O_RDONLY | O_BINARY);
if (diff_handle < 0)
{
WARN ((0, errno, _("Cannot open file %s"), current_file_name));
report_difference (NULL);
skip_file ((long) current_stat.st_size);
break;
}
status = lseek (diff_handle, offset, 0);
if (status != offset)
{
WARN ((0, errno, _("Cannot seek to %ld in file %s"),
offset, current_file_name));
report_difference (NULL);
break;
}
if (multi_volume_option)
{
assign_string (&save_name, current_file_name);
save_totsize = stat_data.st_size;
/* save_sizeleft is set in read_and_process. */
}
read_and_process ((long) (current_stat.st_size), process_rawdata);
if (multi_volume_option)
assign_string (&save_name, NULL);
status = close (diff_handle);
if (status < 0)
ERROR ((0, errno, _("Error while closing %s"), current_file_name));
break;
}
}
}
