Status compare(std::string file1, std::string file2) {
PcapFileIn pf1(0, file1);
PcapFileIn pf2(0, file2);
while (true) {
bool f1 = pf1.moveNext();
bool f2 = pf2.moveNext();
if (f1 != f2) {
if (f1 == false)
return this->reportDifference(file1 + " is shorter");
if (f2 == false)
return this->reportDifference(file2 + " is shorter");
}
if (!f1)
break;
std::unique_ptr<PcapPacket> p1 = pf1.current();
std::unique_ptr<PcapPacket> p2 = pf2.current();
Status cp = this->comparePackets(std::move(p1), std::move(p2));
if (cp != Status::OK)
return cp;
this->packetIndex++;
}
return Status::OK;
}
int main(void) {
f4(); f5();
// CHECK: call void @f4()
// CHECK: call void @f5()
pf1(); pf2(); pf4(); pf5();
// CHECK: call void %{{.*}}()
// CHECK: call void %{{.*}}()
// CHECK: call void %{{.*}}()
// CHECK: call void %{{.*}}()
return 0;
}
void update(const Real val, const Vector<Real> &g, const Real gv, const Vector<Real> &hv,
const Real weight) {
Real pf1(0), pf2(0), c(0), one(1);
for (int i = 0; i < size_; i++) {
pf1 = plusFunction_->evaluate(val-xvar_[i],1);
pf2 = plusFunction_->evaluate(val-xvar_[i],2);
c = weight*coeff_[i]/(one-prob_[i])*pf2*(gv-vvar_[i]);
vec_[i] -= c;
//c *= (gv-vvar_[i]);
RiskMeasure<Real>::hv_->axpy(c,g);
c = weight*coeff_[i]/(one-prob_[i])*pf1;
RiskMeasure<Real>::hv_->axpy(c,hv);
}
}
int main(void) {
f4(); f5(); f6();
// CHECK: call x86_fastcallcc void @f4()
// CHECK: call x86_stdcallcc void @f5()
// CHECK: call x86_thiscallcc void @f6()
pf1(); pf2(); pf3(); pf4(); pf5(); pf6();
// CHECK: call x86_fastcallcc void %{{.*}}()
// CHECK: call x86_stdcallcc void %{{.*}}()
// CHECK: call x86_thiscallcc void %{{.*}}()
// CHECK: call x86_fastcallcc void %{{.*}}()
// CHECK: call x86_stdcallcc void %{{.*}}()
// CHECK: call x86_thiscallcc void %{{.*}}()
return 0;
}
bool Surface::collapse(Edge& e)
{
timespec t0,t1,t;
clock_gettime(CLOCK_REALTIME,&t0);
Point* p1 = e.p1;
Point* p2 = e.p2;
assert(p1);
assert(p2);
if(p1->faces.size() ==0 || p2->faces.size()==0) //Do not simplify boundary corners
{
//cerr << "*ERROR: EMPTY VERTEX.\n";
failed_collapses++;
//cout << redtty << "failed.\n" << deftty;
return false;
}
//Iterating faces
vector<Face*> for_removal;
//clock_gettime(CLOCK_REALTIME,&t0);
for(vector<Face*>::iterator fit = p1->faces.begin(); fit!=p1->faces.end(); ++fit)
{
bool removeface = false;
vector<Point*>::iterator auxp1;
for(vector<Point*>::iterator pit = (*fit)->points.begin(); pit != (*fit)->points.end() ; ++pit)
{
if((*pit) == p2)
{
removeface = true;
break;
}
else if ((*pit) == p1)
{
auxp1 = pit;
}
}
if(removeface) //p1 and p2 share face, remove it.
{
for_removal.push_back((*fit));
}
else //Swap p1 for p2 for this face
{
//Face is about to be modified. Checking intersection.
Point3 p30((*fit)->points[0]->x,(*fit)->points[0]->y,(*fit)->points[0]->z);
Point3 p31((*fit)->points[1]->x,(*fit)->points[1]->y,(*fit)->points[1]->z);
Point3 p32((*fit)->points[2]->x,(*fit)->points[2]->y,(*fit)->points[2]->z);
Triangle3 face(p30,p31,p32);
for(face_vec_it fit2 = m_faces.begin(); fit2 != m_faces.end(); ++fit2)
{
Face* f = (*fit2);
Point3 pf0(f->points[0]->x,f->points[0]->y,f->points[0]->z);
Point3 pf1(f->points[1]->x,f->points[1]->y,f->points[1]->z);
Point3 pf2(f->points[2]->x,f->points[2]->y,f->points[2]->z);
Triangle3 face2(pf0,pf1,pf2);
if(CGAL::do_intersect(face,face2))
{
cerr << "***Faces " << (*fit)->id << " X " << f->id << endl;
}
}
(*auxp1) = p2;
p2->faces.push_back((*fit));
}
}
//cerr << "Removing faces: ";
for(vector<Face*>::iterator it = for_removal.begin(); it != for_removal.end(); ++it)
{
//cerr << (*it)->id << " ";
removeFace(*it);
(*it)->removed = true;
//delete (*it);
}
//Set position of p2 as midpoint between p1-p2
p2->x = e.placement->x;
p2->y = e.placement->y;
p2->z = e.placement->z;
clock_gettime(CLOCK_REALTIME,&t1);
t = diff(t0,t1);
time_faces+= getNanoseconds(t);
//TODO: more efficient to use std::remove_if
clock_gettime(CLOCK_REALTIME,&t0);
removeEdge(m_edges[e.id]);
vector<Edge*> edges_to_remove;
edge_vec_it eit = p1->to.begin();
//Remove double edges to
while(eit != p1->to.end())
{
Edge* e = (*eit);
bool found = false;
edge_vec_it it = p2->to.begin();
while(it != p2->to.end())
{
Edge* e2 = (*it);
if(e->p1->id == e2->p1->id)
{
//cerr << "Found " << e->id << " " << e->p1->id << " " << e->p2->id << endl;
edges_to_remove.push_back(e);
found = true;
break;
}
it++;
}
if(!found)
{
e->p2 = p2;
if(e->p1->id == e->p2->id)
edges_to_remove.push_back(e);
}
eit++;
}
//Remove double edges from
eit = p1->from.begin();
while(eit!=p1->from.end())
{
Edge* e = (*eit);
bool found = false;
edge_vec_it it = p2->from.begin();
while(it != p2->from.end())
{
Edge* e2 = (*it);
if(e->p2->id == e2->p2->id)
{
//cerr << "Found from " << e->id << " " << e->p1->id << " " <<e->p2->id << endl;
edges_to_remove.push_back(e);
found =true;
break;
}
it++;
}
if(!found)
{
e->p1=p2;
if(e->p1->id == e->p2->id)
edges_to_remove.push_back(e);
}
eit++;
}
eit = edges_to_remove.begin();
while(eit != edges_to_remove.end())
{
removeEdge(*eit);
eit++;
}
//Append p1 edges to p2
p2->to.insert(p2->to.end(), p1->to.begin(), p1->to.end());
p2->from.insert(p2->from.end(),p1->from.begin(), p1->from.end());
clock_gettime(CLOCK_REALTIME,&t1);
t = diff(t0,t1);
time_edges += getNanoseconds(t);
//Can remove point p1
clock_gettime(CLOCK_REALTIME,&t0);
removePoint(p1);
clock_gettime(CLOCK_REALTIME,&t1);
t = diff(t0,t1);
time_point+=getNanoseconds(t);
return true;
}
void CoreAudioOutDriver::open(device_id_t device,
int sample_rate,
sample_format form,
int channels,
int num_samples,
int num_periods)
{
if (this->is_open())
throw std::logic_error("Device already open");
if (form != SF_16LE)
throw std::invalid_argument("Unknown sample format");
m_impl->m_logger = logger;
AudioDeviceID devid = GetDeviceID(logger, device);
if (devid == kAudioDeviceUnknown)
throw std::invalid_argument("Unknown device id");
OSStatus err;
const bool isInput = false;
UInt32 propsize;
AudioValueRange bufferRange;
// check that the desired value is within the allowed range
propsize = sizeof(bufferRange);
err = AudioDeviceGetProperty(devid, 0, false,
kAudioDevicePropertyBufferFrameSizeRange,
&propsize,
&bufferRange);
if (err != kAudioHardwareNoError)
{
throw std::runtime_error("Could not get buffer range");
}
propsize = sizeof(UInt32);
UInt32 frames = my_min<int>(my_max<int>(num_samples,
(int) bufferRange.mMinimum),
(int) bufferRange.mMaximum);
err = AudioDeviceSetProperty(devid, NULL, 0, isInput,
kAudioDevicePropertyBufferFrameSize,
propsize, &frames);
if (err != kAudioHardwareNoError)
{
throw std::runtime_error("Could not set buffer size");
}
propsize = sizeof(frames);
err = AudioDeviceGetProperty(devid, 0, isInput,
kAudioDevicePropertyBufferFrameSize,
&propsize, &frames);
if (err != kAudioHardwareNoError)
{
throw std::runtime_error("Could not read buffer size");
}
char bbc[256] = {0};
sprintf(bbc, "Buffer size in frames: %i", frames);
logger(2, bbc);
Float64 sampleRate = sample_rate;
propsize = sizeof(sampleRate);
err = AudioDeviceSetProperty(devid, NULL, 0, isInput,
kAudioDevicePropertyNominalSampleRate,
propsize, &sampleRate);
if (err != kAudioHardwareNoError)
{
throw std::runtime_error("Could not set sample rate");
}
print_info(devid, logger, isInput);
propsize = sizeof(m_impl->m_format);
err = AudioDeviceGetProperty(devid, 0, isInput,
kAudioDevicePropertyStreamFormat,
&propsize,
&m_impl->m_format);
if (err != kAudioHardwareNoError)
{
throw std::runtime_error("Could not get audio format");
}
// Desired format
memset(&m_impl->m_input_format, 0, sizeof(m_impl->m_input_format));
// set channels, format to SF_16LE
m_impl->m_input_format.mSampleRate = sample_rate;
m_impl->m_input_format.mFormatID = kAudioFormatLinearPCM;
m_impl->m_input_format.mFormatFlags
= kLinearPCMFormatFlagIsSignedInteger |
kLinearPCMFormatFlagIsPacked;
m_impl->m_input_format.mBytesPerPacket = 2*channels;
m_impl->m_input_format.mFramesPerPacket = 1;
m_impl->m_input_format.mBytesPerFrame = m_impl->m_input_format.mBytesPerPacket;
m_impl->m_input_format.mChannelsPerFrame = channels;
m_impl->m_input_format.mBitsPerChannel = 16;
#define USE_COMPLEX_AUDIO_CONVERTER
//#define USE_SIMPLE_AUDIO_CONVERTER
#if defined(USE_SIMPLE_AUDIO_CONVERTER)
m_impl->m_converter = new SimpleConverter(m_impl->m_input_format,
m_impl->m_format);
#elif defined (USE_COMPLEX_AUDIO_CONVERTER)
m_impl->m_converter = new ComplexConverter(m_impl->m_input_format,
m_impl->m_format);
#else
// TODO: this works only for 2 channels float to 1 channel mono 16LE!
m_impl->m_converter = new Mono16LEPCMToStereoFloat;
#endif
print_format pf1(logger, "Device Format\n");
pf1(m_impl->m_format);
print_format pf2(logger, "Input Format\n");
pf2(m_impl->m_input_format);
// Set the buffer latency (audio output is only started after
// the buffer contains m_min_buffer samples).
m_impl->m_min_buffer = num_samples*num_periods;
m_impl->m_ID = devid;
AudioDeviceAddIOProc(devid, Impl::OutputIOProc, m_impl.get());
}
void pf(double* fvals, int N, int df1, int df2){
int i;
for(i=0; i<N; i++){fvals[i]=pf1(fvals[i], df1, df2);}
}
