static void DetectCacheAndTLB(size_t& descriptorFlags)
{
const Descriptors descriptors = GetDescriptors();
for(Descriptors::const_iterator it = descriptors.begin(); it != descriptors.end(); ++it)
{
const Descriptor descriptor = *it;
if(HandleSpecialDescriptor(descriptor, descriptorFlags))
continue;
const Characteristics* characteristics = CharacteristicsFromDescriptor(*it);
if(!characteristics)
continue;
if((descriptorFlags & SKIP_CACHE_DESCRIPTORS) && !characteristics->IsTLB())
continue;
x86_x64::Cache cache;
cache.Initialize(characteristics->Level(), characteristics->Type());
cache.numEntries = characteristics->NumEntries();
cache.entrySize = characteristics->EntrySize();
cache.associativity = characteristics->associativity;
cache.sharedBy = 1; // (safe default)
if(characteristics->IsTLB())
AddTLB(cache);
else
AddCache(cache);
}
}
static void AppendDescriptors(u32 reg, Descriptors& descriptors)
{
if(IsBitSet(reg, 31)) // register contents are reserved
return;
for(int pos = 24; pos >= 0; pos -= 8)
{
const u8 descriptor = (u8)bits(reg, pos, pos+7);
if(descriptor != 0)
descriptors.push_back(descriptor);
}
}
SSIZE_T parse( BYTE *data, SIZE_T len, Descriptors &descriptors ) {
SSIZE_T offset = 0;
WORD compatibilityLen = RW(data,offset);
if (!compatibilityLen) {
// Ignore if not present
return 2;
}
WORD descriptorCount = RW(data,offset);
printf( "[dsmcc::compatiblity] Compatibility descriptor: dataLen=%ld, descLen=%d, count=%d\n",
len, compatibilityLen, descriptorCount );
// Check if len is ok
if (len < compatibilityLen) {
printf( "[dsmcc::compatiblity] No data available to parse Compatibility descriptor: descLen=%ld, available=%d\n",
len, compatibilityLen );
return compatibilityLen+2;
}
// Parse descriptors
for (WORD desc=0; desc<descriptorCount; desc++) {
Descriptor desc;
desc.type = RB(data,offset);
//BYTE dLen = RB(data,offset);
offset += 1;
desc.specifier = RDW(data,offset);
desc.model = RW(data,offset);
desc.version = RW(data,offset);
// Parse sub descriptors
BYTE subCount = RB(data,offset);
for (BYTE sub=0; sub<subCount; sub++) {
BYTE subType = RB(data,offset);
BYTE subLen = RB(data,offset);
// AdditionalInformation
offset += subLen;
printf( "[dsmcc::compatibility] Warning, subdescriptor not parsed: count=%d, type=%x, len=%x\n", subCount, subType, subLen );
}
descriptors.push_back( desc );
}
return compatibilityLen+2;
}
void RemoveAndDeleteDescriptors(Descriptors read_descriptors,
Descriptors write_descriptors,
Descriptors delete_descriptors) {
Descriptors::iterator iter;
for (iter = read_descriptors.begin(); iter != read_descriptors.end();
++iter) {
m_ss->RemoveReadDescriptor(*iter);
}
for (iter = write_descriptors.begin(); iter != write_descriptors.end();
++iter) {
m_ss->RemoveWriteDescriptor(*iter);
}
for (iter = delete_descriptors.begin(); iter != delete_descriptors.end();
++iter) {
delete *iter;
}
m_ss->Terminate();
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
#if defined (ACE_WIN32)
ACE_UNUSED_ARG (argc);
ACE_UNUSED_ARG (argv);
cout << "HandleExhaustion test not available on Windows" << endl;
#else
try
{
#if !defined (ACE_LACKS_RLIMIT) && defined (RLIMIT_NOFILE)
// We must make sure that our file descriptor limit does not exceed
// the size allowed (in the fd set) by the reactor. If it does, this
// test will fail (in a different way than expected) which is a
// completely different bug than this test is designed to address
// (see Bug #3326).
//
// We must also make sure that this happens before creating the first
// ORB. Otherwise, the reactor will be created with a maximum size of
// the current rlimit for file desriptors (which will later on be
// increased).
rlimit rlim;
if (ACE_OS::getrlimit(RLIMIT_NOFILE, &rlim) == 0)
{
cout << "server evaluating rlimit, cur = "
<< rlim.rlim_cur << " max = " << rlim.rlim_max
<< " reactor max = "
<< ACE_DEFAULT_SELECT_REACTOR_SIZE << endl;
if (rlim.rlim_cur < static_cast<rlim_t> (ACE_DEFAULT_SELECT_REACTOR_SIZE) &&
rlim.rlim_max > static_cast<rlim_t> (ACE_DEFAULT_SELECT_REACTOR_SIZE))
{
rlim.rlim_cur = ACE_DEFAULT_SELECT_REACTOR_SIZE;
rlim.rlim_max = ACE_DEFAULT_SELECT_REACTOR_SIZE;
ACE_OS::setrlimit(RLIMIT_NOFILE, &rlim);
cout << "server set rlimit_nofile" << endl;
}
}
#else
cout << "server does not support setting rlimit, reactor max = "
<< ACE_DEFAULT_SELECT_REACTOR_SIZE << endl;
#endif /* !ACE_LACKS_RLIMIT && RLIMIT_NOFILE */
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
if (CORBA::is_nil (root_poa.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Panic: nil RootPOA\n"),
1);
if (parse_args (argc, argv) != 0)
return 1;
Test_i* test_i;
ACE_NEW_RETURN (test_i,
Test_i (orb.in ()),
1);
PortableServer::ServantBase_var owner_transfer(test_i);
PortableServer::ObjectId_var id = root_poa->activate_object (test_i);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
Test_var test = Test::_narrow (object.in ());
CORBA::String_var ior = orb->object_to_string (test.in ());
// Output the IOR to the <ior_output_file>
FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file %s for writing IOR: %C\n",
ior_output_file,
ior.in ()),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
poa_manager->activate ();
Descriptors descriptors;
descriptors.leak (
#ifdef _WRS_KERNEL
"server.out");
#else
argv[0]);
#endif
ACE_Time_Value tv (10);
orb->run (tv);
cout << "Server: closing some fds" << endl;
descriptors.allow_accepts ();
orb->run ();
orb->destroy ();
if (!descriptors.ok ())
{
cout << "Server: the accept error never occurred" << endl;
ACE_ERROR_RETURN ((LM_ERROR, "The accept error never occurred\n"), 1);
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
#endif /* ACE_WIN32 */
return 0;
}
void Pipeline::extract_features(const Images& images,CamFrames& cam_Frames,DescriptorsVec& descriptors_vec)
{
Logger _log("Step 1 (features)");
const int n = images.size();
cam_Frames = CamFrames(n);
descriptors_vec = DescriptorsVec(n);
// Create a SIFT detector
// Bernhard-checked
const int feature_num = 0; // Default: 0
const int octavelayers_num = 4; // Default: 3
const double constrast_thresh = .04f; // Default: 0.04 (larger: less feats)
const double edge_threshold = 4.0f; // Default: 10 (larger: more feats)
const double sigma = 1.6f; // Default: 1.6
Ptr<Feature2D> sift_detector = SIFT::create(feature_num,
octavelayers_num, constrast_thresh, edge_threshold, sigma);
// create brist detector
// parameters for brisk : int thresh = 30, int octaves = 3, float patternScale = 1.0f
// const int thresh = 70;
// const int octaves = 2;
// Ptr<Feature2D> brisk_detector = BRISK::create(thresh, octaves);
// detect features in a loop
#pragma omp parallel for
for (int i = 0; i < n; ++i)
{
Image image = images[i];
KeyPoints key_points;
Descriptors descriptors;
// Detect keypoints and calculate descriptor vectors
sift_detector->detectAndCompute(image.gray, noArray(), key_points, descriptors);
KeyPoints keep_key_points;
Descriptors keep_descriptors;
Depths keep_depths;
// Keep keypoints with valid depth only
// Valid depth is [0.4, 8]m
for (size_t k = 0; k < key_points.size(); k++)
{
float d = image.dep.at<float>(key_points[k].pt);
if (d < 400.f || d > 8000) continue;
keep_key_points.push_back(key_points[k]);
keep_descriptors.push_back(descriptors.row(k));
keep_depths.push_back(d);
}
// wrap keypoints to cam_Frame and add in to cam_Frames
cam_Frames[i] = (CamFrame) {i, keep_key_points,keep_depths};
descriptors_vec[i] = keep_descriptors;
_log("Found %d key points in image %d.", keep_key_points.size(), i);
}
_log.tok();
}