Transformation<double> StereoCartography::estimateOdometry(const vector<Feature> & featureVec)
{
//Matching
int numLandmarks = LM.size();
int numActive = min(300, numLandmarks);
vector<Feature> lmFeatureVec;
// cout << "ca va" << endl;
for (unsigned int i = numLandmarks - numActive; i < numLandmarks; i++)
{
lmFeatureVec.push_back(Feature(Vector2d(0, 0), LM[i].d));
}
// cout << "ca va" << endl;
Matcher matcher;
vector<int> matchVec;
matcher.bruteForce(featureVec, lmFeatureVec, matchVec);
Odometry odometry(trajectory.back(), stereo.TbaseCam1, stereo.cam1);
// cout << "ca va" << endl;
for (unsigned int i = 0; i < featureVec.size(); i++)
{
const int match = matchVec[i];
if (match == -1) continue;
odometry.observationVec.push_back(featureVec[i].pt);
odometry.cloud.push_back(LM[numLandmarks - numActive + match].X);
}
// cout << "cloud : " << odometry.cloud.size() << endl;
//RANSAC
odometry.Ransac();
// cout << odometry.TorigBase << endl;
//Final transformation computation
odometry.computeTransformation();
// cout << odometry.TorigBase << endl;
return odometry.TorigBase;
}
std::list<const LLToast*> LLScreenChannel::findToasts(const Matcher& matcher)
{
std::list<const LLToast*> res;
// collect stored toasts
for (std::vector<ToastElem>::iterator it = mStoredToastList.begin(); it
!= mStoredToastList.end(); it++)
{
const LLToast* toast = it->getToast();
if (toast && matcher.matches(toast->getNotification()))
{
res.push_back(toast);
}
}
// collect displayed toasts
for (std::vector<ToastElem>::iterator it = mToastList.begin(); it
!= mToastList.end(); it++)
{
const LLToast* toast = it->getToast();
if (toast && matcher.matches(toast->getNotification()))
{
res.push_back(toast);
}
}
return res;
}
int main() {
Matcher match;
for (int i=1000; i<=100000; i+=1000) {
clock_timer timer;
list.clear();
for(int j = 0; j <= i; ++j){
list.push_back(j);
}
timer.start_timer();
int hits1 = match.nSquare(i*2+1, list);
//int hits2 = match.nLogn(i*2+1, list);
timer.stop_timer();
dataVector.push_back(std::make_pair(i, timer.duration));
std::cout << "found: " << hits1 << std::endl;
}
std::ofstream myfile;
myfile.open("A.txt");
while(!dataVector.empty()) {
std::cout<<dataVector.front().first <<" , "<<dataVector.front().second <<std::endl;
myfile<< dataVector.front().first << "\t" << dataVector.front().second << "\n";
dataVector.pop_front();
}
myfile.close();
return 0;
}
void AddWordMatcherImpl::operator()( boost::ptr_vector<Matcher> & matchers, const std::string & base, SpeechPart speechPart, uint index, boost::ptr_vector< Restriction > & restrictions ) const {
Matcher * matcher = new WordMatcher( base, speechPart );
matcher->variable = Variable( speechPart, index );
matcher->addRestrictions( restrictions );
matchers.push_back( matcher );
}
TEST(MatcherTest, PropertyTesting)
{
Matcher<Sut&> m = Field(&Sut::d, Eq(0));
MockIntf mock;
Sut testObj(&mock);
EXPECT_FALSE(m.Matches(testObj));
testObj.d=0;
EXPECT_TRUE(m.Matches(testObj));
}
TEST(MatcherTest, MatchAndExplain)
{
Matcher<const Sut&> m = checkSumGreaterThan(10);
StringMatchResultListener listener;
MockIntf mock;
Sut testObj(&mock);
testObj.setA(5);
testObj.setB(6);
EXPECT_TRUE(m.MatchAndExplain(testObj, &listener));
testObj.setB(1);
EXPECT_FALSE(m.MatchAndExplain(testObj, &listener));
}
/// unlinkNode - Unlink the specified node from this chain. If Other == this,
/// we unlink the next pointer and return it. Otherwise we unlink Other from
/// the list and return this.
Matcher *Matcher::unlinkNode(Matcher *Other) {
if (this == Other)
return takeNext();
// Scan until we find the predecessor of Other.
Matcher *Cur = this;
for (; Cur && Cur->getNext() != Other; Cur = Cur->getNext())
/*empty*/;
if (Cur == 0) return 0;
Cur->takeNext();
Cur->setNext(Other->takeNext());
return this;
}
void LLScreenChannel::closeHiddenToasts(const Matcher& matcher)
{
// since we can't guarantee that close toast operation doesn't change mToastList
// we collect matched toasts that should be closed into separate list
std::list<LLToast*> toasts;
for (std::vector<ToastElem>::iterator it = mToastList.begin(); it
!= mToastList.end(); it++)
{
LLToast* toast = it->getToast();
// add to list valid toast that match to provided matcher criteria
if (toast != NULL && !toast->isDead() && toast->getNotification() != NULL
&& !toast->getVisible() && matcher.matches(toast->getNotification()))
{
toasts.push_back(toast);
}
}
// close collected toasts
for (std::list<LLToast*>::iterator it = toasts.begin(); it
!= toasts.end(); it++)
{
LLToast* toast = *it;
toast->closeFloater();
}
}
//------------------------------sched_call-------------------------------------
uint Block::sched_call( Matcher &m, Block_Array &bbs, uint node_cnt, Node_List &worklist, int *ready_cnt, MachCallNode *mcall, VectorSet &next_call ) {
RegMask regs;
// Schedule all the users of the call right now. All the users are
// projection Nodes, so they must be scheduled next to the call.
// Collect all the defined registers.
for (DUIterator_Fast imax, i = mcall->fast_outs(imax); i < imax; i++) {
Node* n = mcall->fast_out(i);
assert( n->Opcode()==Op_MachProj, "" );
--ready_cnt[n->_idx];
assert( !ready_cnt[n->_idx], "" );
// Schedule next to call
_nodes.map(node_cnt++, n);
// Collect defined registers
regs.OR(n->out_RegMask());
// Check for scheduling the next control-definer
if( n->bottom_type() == Type::CONTROL )
// Warm up next pile of heuristic bits
needed_for_next_call(n, next_call, bbs);
// Children of projections are now all ready
for (DUIterator_Fast jmax, j = n->fast_outs(jmax); j < jmax; j++) {
Node* m = n->fast_out(j); // Get user
if( bbs[m->_idx] != this ) continue;
if( m->is_Phi() ) continue;
if( !--ready_cnt[m->_idx] )
worklist.push(m);
}
}
// Act as if the call defines the Frame Pointer.
// Certainly the FP is alive and well after the call.
regs.Insert(m.c_frame_pointer());
// Set all registers killed and not already defined by the call.
uint r_cnt = mcall->tf()->range()->cnt();
int op = mcall->ideal_Opcode();
MachProjNode *proj = new (1) MachProjNode( mcall, r_cnt+1, RegMask::Empty, MachProjNode::fat_proj );
bbs.map(proj->_idx,this);
_nodes.insert(node_cnt++, proj);
for( OptoReg::Name r = OptoReg::Name(0); r < _last_Mach_Reg; r=OptoReg::add(r,1) ) {
if( !regs.Member(r) ) { // Not already defined by the call
// Save-on-call register?
if( (m._register_save_policy[r] == 'C') ||
(m._register_save_policy[r] == 'A') ||
((m._register_save_policy[r] == 'E') &&
(op == Op_CallRuntime ||
op == Op_CallNative ||
op == Op_CallInterpreter ||
op == Op_CallLeaf)) ) {
proj->_rout.Insert(r);
}
}
}
return node_cnt;
}
void readPapers(int papers, Scanner scanIn) {
int paper;
for (paper = 1; paper <= papers; paper++) {
String paperAuthors;
paperAuthors = scanIn.nextLine();
#ifdef DEBUG
printf("paper #%d %s\n", paper, paperAuthors);
#endif
Author authors[] = new Author[Author.MAX_PAPER_AUTHORS];
int authorsIndex = 0;
Pattern p = Pattern.compile("\\s*(\\S*)[,]\\s*(\\S*)[,:]");
Matcher m = p.matcher(paperAuthors);
while (m.find()) {
String lname = m.group(1);
String fname = m.group(2);
if (debug) {
printf("\t'%s' => '%s', '%s'\n", paperAuthors, lname, fname);
}
authors[authorsIndex] = Author.find(fname, lname);
if (authors[authorsIndex] == null) {
if (lname.length() == 0 || fname.length() == 0) {
continue;
}
authors[authorsIndex] = new Author(fname, lname);
}
authorsIndex++;
}
for (int i = 0; i < authorsIndex; i++) {
for (int j = 0; j < authorsIndex; j++) {
authors[i].publicouCom(authors[j]);
}
}
}
}
void Tok::Unresolve(Matcher const &matcher)
{
int i;
TokIdNode *nd;
for(i = node.size(); i--;)
{
for(nd = node[i]; nd->v_prev != 0 && !matcher.Match(nd); nd = nd->v_prev)
{
unres[i + 1].push_front(nd->id[0]);
}
}
}
int AdHunterImpl::getBestAdTargets(double minPrice, int pagesPerSite, vector<Match>& matches)
{
matches.clear();
for (int i = 0; i < m_seedSites.size(); i++)
{
Crawler c(m_seedSites[i]);
int page = 0;
for (Document* d = c.crawl(); page < pagesPerSite && d != NULL; page++, d = c.crawl())
m_matcher.process(*d,minPrice,matches);
}
return matches.size();
}
void find(string text, string pattern, int expect) {
Matcher * impl = getImpl(pattern);
clock_t start_time = clock();
int pos = impl->find(text);
clock_t end_time = clock();
printf("pos :%d\texpect : %d\n", pos, expect);
assert(pos == expect);
// cout << pattern.size() << endl;
string out_text = (text.size() <= 100) ? text : "Too Long";
string out_pattern =(pattern.size() <= 100) ? pattern : "Too Long";
printf("start time : %lu\n", start_time);
printf("end time : %lu\n", end_time);
printf("text : %s\npattern : %s\nmatch positon : %d\nexecution time: %lfs\n\n",
out_text.c_str(), out_pattern.c_str() , pos, ((double) end_time - start_time) / CLOCKS_PER_SEC);
delete impl;
}
int MatcherDecode(SimpleImage* image,char code[4])
{
SimpleImage* gray = siCreateImage(image->width,image->height,1);
if (image->nChannels != 1)
{
siRgbToGray(image,gray);
}
//siThreshold(gray,gray,150,255);
siThreshold(gray,gray,115,255);
int ret = thiz.Decode(gray,code);
siReleaseImage(&gray);
return ret;
}
void QueryPreProcessor::parseQuery(string query) {
vector<string> first_split = split(query, ';'); //
vector<string> result_part;
vector<string> query_part;
Matcher* m = new Matcher();
for(size_t i = 0 ; i < first_split.size() ; i ++)
{
if(!m->checkTokens(first_split[i], "select"))
result_part.push_back(first_split[i]);
else
query_part.push_back(first_split[i]);
}
delete m;
if(query_part.size() == 0) {
exc->throwException();
}
//writeVector(result_part);
//cout << m->checkProcName(result_part[0]) << endl;
//cout << m->checkVarName(result_part[0]) << endl;
//cout << m->checkStmt_(result_part[0]) << endl;
//cout << m->checkAll(result_part[0]) << endl;
vector<Field> fields = makeFields(result_part);
setFields(fields);
//writeVector(query_part);
makeTree(query_part);
/*
for (int j = 0; j < fields.size(); j++) {
cout << fields[j].getType() << " " << fields[j].getValue() << endl;
}*/
}
int readCases(int names, Scanner *scanIn, Collection<Entry<String, Author>> *theMap,
Set<Author> *targets) {
int nameInd;
for (nameInd = 1; nameInd <= names; nameInd++) {
String bigname;
bigname = scanIn.nextLine();
#ifdef DEBUG
printf("\tname #%d %s\n", nameInd, bigname);
#endif
Pattern p = Pattern.compile("\\s*(\\S*)[,]\\s*(\\S*)");
Matcher m = p.matcher(bigname);
if (m.find()) {
String lname = m.group(1);
String fname = m.group(2);
#ifdef DEBUG
printf("\tmatcher2'%s' => '%s', '%s'\n", bigname, lname, fname);
#endif
Author a = Author.find(fname, lname);response
theMap.add(new MyEntry(bigname, a));
if (a != null) {
targets.add(a);
#ifdef DEBUG
printf("\tauthor case '%s' is #%d\n", a.lname, targets.size());
#endif
}
} else {
theMap.add(new Entry<String, Author>(bigname, null));
}
}
return nameInd;
}
TokArr Tok::GetDescendants(Matcher const &matcher) const
{
TokIdNode *nd[2];
TokArr rv;
for(nd[0] = TokIdNode::GetLeaf(nd[1] = Node()); nd[0] != nd[1]; nd[0] = TokIdNode::GetNext(nd[0], nd[1]))
{
if(matcher.Match(nd[0]))
{
rv.push_back(nd[0]);
}
}
return rv;
}
void Scanner::doUntil(Matcher const & matcher, std::function<void(char)> before, std::function<void(char)> after)
{
if( ! is ) return;
int g;
while( (g = is.get()) != std::istream::traits_type::eof() ) {
char ch = g;
before(ch);
if( matcher.matches(ch) ) {
is.putback(ch);
break;
}
after(ch);
}
}
void Foam::inplaceSubsetMatchingStrings
(
const Matcher& matcher,
StringListType& lst,
const bool invert
)
{
label nElem = 0;
forAll(lst, elemI)
{
if (matcher.match(lst[elemI]) ? !invert : invert)
{
lst[nElem++] = lst[elemI];
}
}
lst.setSize(nElem);
}
void LLNotifyBoxView::purgeMessagesMatching(const Matcher& matcher)
{
// Make a *copy* of the child list to iterate over
// since we'll be removing items from the real list as we go.
LLView::child_list_t notification_queue(*getChildList());
for(LLView::child_list_iter_t iter = notification_queue.begin();
iter != notification_queue.end();
iter++)
{
if (isGroupNotifyBox(*iter))
continue;
LLNotifyBox* notification = static_cast<LLNotifyBox*>(*iter);
if (matcher.matches(notification->getNotification()))
{
removeChild(notification);
}
}
}
StringListType Foam::subsetMatchingStrings
(
const Matcher& matcher,
const StringListType& lst,
const bool invert
)
{
StringListType newLst(lst.size());
label nElem = 0;
forAll(lst, elemI)
{
if (matcher.match(lst[elemI]) ? !invert : invert)
{
newLst[nElem++] = lst[elemI];
}
}
newLst.setSize(nElem);
return newLst;
}
Foam::labelList Foam::findMatchingStrings
(
const Matcher& matcher,
const UList<StringType>& lst,
const bool invert
)
{
labelList indices(lst.size());
label nElem = 0;
forAll(lst, elemI)
{
if (matcher.match(lst[elemI]) ? !invert : invert)
{
indices[nElem++] = elemI;
}
}
indices.setSize(nElem);
return indices;
}
//=============================================================================
//------------------------------PhaseCFG---------------------------------------
PhaseCFG::PhaseCFG(ResourceArea*a,RootNode*r,Matcher&m):
Phase(CFG),
_bbs(a),
_root(r)
#ifndef PRODUCT
, _trace_opto_pipelining(TraceOptoPipelining || C->method_has_option("TraceOptoPipelining"))
#endif
{
ResourceMark rm;
// I'll need a few machine-specific GotoNodes. Make an Ideal GotoNode,
// then Match it into a machine-specific Node. Then clone the machine
// Node on demand.
Node *x = new (C, 1) GotoNode(NULL);
x->init_req(0, x);
_goto = m.match_tree(x);
assert(_goto != NULL, "");
_goto->set_req(0,_goto);
// Build the CFG in Reverse Post Order
_num_blocks = build_cfg();
_broot = _bbs[_root->_idx];
}
std::vector< std::pair< TokIdNode *, int > > TokIdNode::AmbigResolve(
TokIdNode const *node,
std::deque< TokId >::const_iterator arr,
int len,
Matcher const &matcher,
TokIdNode const *context,
TokIdNode const *subroot)
{
int i;
Map::const_iterator it, itEnd;
std::vector< std::pair< TokIdNode *, int > > rv[2];
TokIdNode const *nd;
if(len == 0)
{
if(node && node->IsInContext(context) && matcher.Match(node))
{
rv[0].push_back(std::make_pair((TokIdNode *)node, 0));
}
return rv[0];
}
if(node && !context->IsInContext(node) && !node->IsInContext(context))
{
return rv[0];
}
if(!context->IsInContext(subroot))
{
PNL_THROW(pnl::CBadArg, "context must lie in subtree rooted at subroot");
}
if(node == 0 && subroot->Match(arr[0]))
{
rv[1] = AmbigResolve(subroot, arr + 1, len - 1, matcher, context, subroot);
for(i = rv[1].size(); i--;)
{
rv[0].push_back(std::make_pair(rv[1][i].first, rv[1][i].second + 1));
}
}
nd = node ? node : subroot;
it = nd->desc.find(arr[0]);
if(it != nd->desc.end())
{
for(itEnd = nd->desc.upper_bound(arr[0]); it != itEnd; ++it)
{
rv[1] = AmbigResolve(it->second, arr + 1, len - 1, matcher, context, subroot);
for(i = rv[1].size(); i--;)
{
rv[0].push_back(std::make_pair(rv[1][i].first, rv[1][i].second + 1));
}
}
}
if(rv[0].empty())
{
rv[0].push_back(std::make_pair((TokIdNode *)node, 0));
}
return rv[0];
}
bool run(OperationContext* txn,
const std::string& db,
BSONObj& cmdObj,
int options,
std::string& errmsg,
BSONObjBuilder& result) final {
const bool includeAll = cmdObj["$all"].trueValue();
const bool ownOpsOnly = cmdObj["$ownOps"].trueValue();
// Filter the output
BSONObj filter;
{
BSONObjBuilder b;
BSONObjIterator i(cmdObj);
invariant(i.more());
i.next(); // skip {currentOp: 1} which is required to be the first element
while (i.more()) {
BSONElement e = i.next();
if (str::equals("$all", e.fieldName())) {
continue;
} else if (str::equals("$ownOps", e.fieldName())) {
continue;
}
b.append(e);
}
filter = b.obj();
}
std::vector<BSONObj> inprogInfos;
BSONArrayBuilder inprogBuilder(result.subarrayStart("inprog"));
for (ServiceContext::LockedClientsCursor cursor(txn->getClient()->getServiceContext());
Client* client = cursor.next();) {
invariant(client);
stdx::lock_guard<Client> lk(*client);
if (ownOpsOnly &&
!AuthorizationSession::get(txn->getClient())->isCoauthorizedWithClient(client)) {
continue;
}
const OperationContext* opCtx = client->getOperationContext();
if (!includeAll) {
// Skip over inactive connections.
if (!opCtx)
continue;
}
BSONObjBuilder infoBuilder;
// The client information
client->reportState(infoBuilder);
const auto& clientMetadata =
ClientMetadataIsMasterState::get(client).getClientMetadata();
if (clientMetadata) {
auto appName = clientMetadata.get().getApplicationName();
if (!appName.empty()) {
infoBuilder.append("appName", appName);
}
}
// Operation context specific information
infoBuilder.appendBool("active", static_cast<bool>(opCtx));
if (opCtx) {
infoBuilder.append("opid", opCtx->getOpID());
if (opCtx->isKillPending()) {
infoBuilder.append("killPending", true);
}
CurOp::get(opCtx)->reportState(&infoBuilder);
// LockState
Locker::LockerInfo lockerInfo;
opCtx->lockState()->getLockerInfo(&lockerInfo);
fillLockerInfo(lockerInfo, infoBuilder);
}
// If we want to include all results or if the filter is empty, then we can append
// straight to the inprogBuilder, but otherwise we should run the filter Matcher
// outside this loop so we don't lock the ServiceContext while matching - in some cases
// this can cause deadlocks.
if (includeAll || filter.isEmpty()) {
inprogBuilder.append(infoBuilder.obj());
} else {
inprogInfos.emplace_back(infoBuilder.obj());
}
}
if (!inprogInfos.empty()) {
// We use ExtensionsCallbackReal here instead of ExtensionsCallbackNoop in order to
// support the use case of having a $where filter with currentOp. However, since we
// don't have a collection, we pass in a fake collection name (and this is okay,
// because $where parsing only relies on the database part of the namespace).
const NamespaceString fakeNS(db, "$dummyNamespaceForCurrop");
const Matcher matcher(filter, ExtensionsCallbackReal(txn, &fakeNS), nullptr);
for (const auto& info : inprogInfos) {
if (matcher.matches(info)) {
inprogBuilder.append(info);
}
}
}
inprogBuilder.done();
if (lockedForWriting()) {
result.append("fsyncLock", true);
result.append("info",
"use db.fsyncUnlock() to terminate the fsync write/snapshot lock");
}
return true;
}
int MatcherInitImage(SimpleImage* image,const char* charArray)
{
return thiz.Init(image,charArray);
}
int MatcherInit(const char* fontData,const char* charArray)
{
return thiz.Init(fontData,charArray);
}
//------------------------------sched_call-------------------------------------
uint Block::sched_call( Matcher &matcher, Block_Array &bbs, uint node_cnt, Node_List &worklist, GrowableArray<int> &ready_cnt, MachCallNode *mcall, VectorSet &next_call ) {
RegMask regs;
// Schedule all the users of the call right now. All the users are
// projection Nodes, so they must be scheduled next to the call.
// Collect all the defined registers.
for (DUIterator_Fast imax, i = mcall->fast_outs(imax); i < imax; i++) {
Node* n = mcall->fast_out(i);
assert( n->is_MachProj(), "" );
int n_cnt = ready_cnt.at(n->_idx)-1;
ready_cnt.at_put(n->_idx, n_cnt);
assert( n_cnt == 0, "" );
// Schedule next to call
_nodes.map(node_cnt++, n);
// Collect defined registers
regs.OR(n->out_RegMask());
// Check for scheduling the next control-definer
if( n->bottom_type() == Type::CONTROL )
// Warm up next pile of heuristic bits
needed_for_next_call(n, next_call, bbs);
// Children of projections are now all ready
for (DUIterator_Fast jmax, j = n->fast_outs(jmax); j < jmax; j++) {
Node* m = n->fast_out(j); // Get user
if( bbs[m->_idx] != this ) continue;
if( m->is_Phi() ) continue;
int m_cnt = ready_cnt.at(m->_idx)-1;
ready_cnt.at_put(m->_idx, m_cnt);
if( m_cnt == 0 )
worklist.push(m);
}
}
// Act as if the call defines the Frame Pointer.
// Certainly the FP is alive and well after the call.
regs.Insert(matcher.c_frame_pointer());
// Set all registers killed and not already defined by the call.
uint r_cnt = mcall->tf()->range()->cnt();
int op = mcall->ideal_Opcode();
MachProjNode *proj = new (matcher.C, 1) MachProjNode( mcall, r_cnt+1, RegMask::Empty, MachProjNode::fat_proj );
bbs.map(proj->_idx,this);
_nodes.insert(node_cnt++, proj);
// Select the right register save policy.
const char * save_policy;
switch (op) {
case Op_CallRuntime:
case Op_CallLeaf:
case Op_CallLeafNoFP:
// Calling C code so use C calling convention
save_policy = matcher._c_reg_save_policy;
break;
case Op_CallStaticJava:
case Op_CallDynamicJava:
// Calling Java code so use Java calling convention
save_policy = matcher._register_save_policy;
break;
default:
ShouldNotReachHere();
}
// When using CallRuntime mark SOE registers as killed by the call
// so values that could show up in the RegisterMap aren't live in a
// callee saved register since the register wouldn't know where to
// find them. CallLeaf and CallLeafNoFP are ok because they can't
// have debug info on them. Strictly speaking this only needs to be
// done for oops since idealreg2debugmask takes care of debug info
// references but there no way to handle oops differently than other
// pointers as far as the kill mask goes.
bool exclude_soe = op == Op_CallRuntime;
// If the call is a MethodHandle invoke, we need to exclude the
// register which is used to save the SP value over MH invokes from
// the mask. Otherwise this register could be used for
// deoptimization information.
if (op == Op_CallStaticJava) {
MachCallStaticJavaNode* mcallstaticjava = (MachCallStaticJavaNode*) mcall;
if (mcallstaticjava->_method_handle_invoke)
proj->_rout.OR(Matcher::method_handle_invoke_SP_save_mask());
}
add_call_kills(proj, regs, save_policy, exclude_soe);
return node_cnt;
}
//------------------------------schedule_local---------------------------------
// Topological sort within a block. Someday become a real scheduler.
bool Block::schedule_local(PhaseCFG *cfg, Matcher &matcher, GrowableArray<int> &ready_cnt, VectorSet &next_call) {
// Already "sorted" are the block start Node (as the first entry), and
// the block-ending Node and any trailing control projections. We leave
// these alone. PhiNodes and ParmNodes are made to follow the block start
// Node. Everything else gets topo-sorted.
#ifndef PRODUCT
if (cfg->trace_opto_pipelining()) {
tty->print_cr("# --- schedule_local B%d, before: ---", _pre_order);
for (uint i = 0;i < _nodes.size();i++) {
tty->print("# ");
_nodes[i]->fast_dump();
}
tty->print_cr("#");
}
#endif
// RootNode is already sorted
if( _nodes.size() == 1 ) return true;
// Move PhiNodes and ParmNodes from 1 to cnt up to the start
uint node_cnt = end_idx();
uint phi_cnt = 1;
uint i;
for( i = 1; i<node_cnt; i++ ) { // Scan for Phi
Node *n = _nodes[i];
if( n->is_Phi() || // Found a PhiNode or ParmNode
(n->is_Proj() && n->in(0) == head()) ) {
// Move guy at 'phi_cnt' to the end; makes a hole at phi_cnt
_nodes.map(i,_nodes[phi_cnt]);
_nodes.map(phi_cnt++,n); // swap Phi/Parm up front
} else { // All others
// Count block-local inputs to 'n'
uint cnt = n->len(); // Input count
uint local = 0;
for( uint j=0; j<cnt; j++ ) {
Node *m = n->in(j);
if( m && cfg->_bbs[m->_idx] == this && !m->is_top() )
local++; // One more block-local input
}
ready_cnt.at_put(n->_idx, local); // Count em up
#ifdef ASSERT
if( UseConcMarkSweepGC || UseG1GC ) {
if( n->is_Mach() && n->as_Mach()->ideal_Opcode() == Op_StoreCM ) {
// Check the precedence edges
for (uint prec = n->req(); prec < n->len(); prec++) {
Node* oop_store = n->in(prec);
if (oop_store != NULL) {
assert(cfg->_bbs[oop_store->_idx]->_dom_depth <= this->_dom_depth, "oop_store must dominate card-mark");
}
}
}
}
#endif
// A few node types require changing a required edge to a precedence edge
// before allocation.
if( n->is_Mach() && n->req() > TypeFunc::Parms &&
(n->as_Mach()->ideal_Opcode() == Op_MemBarAcquire ||
n->as_Mach()->ideal_Opcode() == Op_MemBarVolatile) ) {
// MemBarAcquire could be created without Precedent edge.
// del_req() replaces the specified edge with the last input edge
// and then removes the last edge. If the specified edge > number of
// edges the last edge will be moved outside of the input edges array
// and the edge will be lost. This is why this code should be
// executed only when Precedent (== TypeFunc::Parms) edge is present.
Node *x = n->in(TypeFunc::Parms);
n->del_req(TypeFunc::Parms);
n->add_prec(x);
}
}
}
for(uint i2=i; i2<_nodes.size(); i2++ ) // Trailing guys get zapped count
ready_cnt.at_put(_nodes[i2]->_idx, 0);
// All the prescheduled guys do not hold back internal nodes
uint i3;
for(i3 = 0; i3<phi_cnt; i3++ ) { // For all pre-scheduled
Node *n = _nodes[i3]; // Get pre-scheduled
for (DUIterator_Fast jmax, j = n->fast_outs(jmax); j < jmax; j++) {
Node* m = n->fast_out(j);
if( cfg->_bbs[m->_idx] ==this ) { // Local-block user
int m_cnt = ready_cnt.at(m->_idx)-1;
ready_cnt.at_put(m->_idx, m_cnt); // Fix ready count
}
}
}
Node_List delay;
// Make a worklist
Node_List worklist;
for(uint i4=i3; i4<node_cnt; i4++ ) { // Put ready guys on worklist
Node *m = _nodes[i4];
if( !ready_cnt.at(m->_idx) ) { // Zero ready count?
if (m->is_iteratively_computed()) {
// Push induction variable increments last to allow other uses
// of the phi to be scheduled first. The select() method breaks
// ties in scheduling by worklist order.
delay.push(m);
} else if (m->is_Mach() && m->as_Mach()->ideal_Opcode() == Op_CreateEx) {
// Force the CreateEx to the top of the list so it's processed
// first and ends up at the start of the block.
worklist.insert(0, m);
} else {
worklist.push(m); // Then on to worklist!
}
}
}
while (delay.size()) {
Node* d = delay.pop();
worklist.push(d);
}
// Warm up the 'next_call' heuristic bits
needed_for_next_call(_nodes[0], next_call, cfg->_bbs);
#ifndef PRODUCT
if (cfg->trace_opto_pipelining()) {
for (uint j=0; j<_nodes.size(); j++) {
Node *n = _nodes[j];
int idx = n->_idx;
tty->print("# ready cnt:%3d ", ready_cnt.at(idx));
tty->print("latency:%3d ", cfg->_node_latency->at_grow(idx));
tty->print("%4d: %s\n", idx, n->Name());
}
}
#endif
uint max_idx = (uint)ready_cnt.length();
// Pull from worklist and schedule
while( worklist.size() ) { // Worklist is not ready
#ifndef PRODUCT
if (cfg->trace_opto_pipelining()) {
tty->print("# ready list:");
for( uint i=0; i<worklist.size(); i++ ) { // Inspect entire worklist
Node *n = worklist[i]; // Get Node on worklist
tty->print(" %d", n->_idx);
}
tty->cr();
}
#endif
// Select and pop a ready guy from worklist
Node* n = select(cfg, worklist, ready_cnt, next_call, phi_cnt);
_nodes.map(phi_cnt++,n); // Schedule him next
#ifndef PRODUCT
if (cfg->trace_opto_pipelining()) {
tty->print("# select %d: %s", n->_idx, n->Name());
tty->print(", latency:%d", cfg->_node_latency->at_grow(n->_idx));
n->dump();
if (Verbose) {
tty->print("# ready list:");
for( uint i=0; i<worklist.size(); i++ ) { // Inspect entire worklist
Node *n = worklist[i]; // Get Node on worklist
tty->print(" %d", n->_idx);
}
tty->cr();
}
}
#endif
if( n->is_MachCall() ) {
MachCallNode *mcall = n->as_MachCall();
phi_cnt = sched_call(matcher, cfg->_bbs, phi_cnt, worklist, ready_cnt, mcall, next_call);
continue;
}
if (n->is_Mach() && n->as_Mach()->has_call()) {
RegMask regs;
regs.Insert(matcher.c_frame_pointer());
regs.OR(n->out_RegMask());
MachProjNode *proj = new (matcher.C, 1) MachProjNode( n, 1, RegMask::Empty, MachProjNode::fat_proj );
cfg->_bbs.map(proj->_idx,this);
_nodes.insert(phi_cnt++, proj);
add_call_kills(proj, regs, matcher._c_reg_save_policy, false);
}
// Children are now all ready
for (DUIterator_Fast i5max, i5 = n->fast_outs(i5max); i5 < i5max; i5++) {
Node* m = n->fast_out(i5); // Get user
if( cfg->_bbs[m->_idx] != this ) continue;
if( m->is_Phi() ) continue;
if (m->_idx >= max_idx) { // new node, skip it
assert(m->is_MachProj() && n->is_Mach() && n->as_Mach()->has_call(), "unexpected node types");
continue;
}
int m_cnt = ready_cnt.at(m->_idx)-1;
ready_cnt.at_put(m->_idx, m_cnt);
if( m_cnt == 0 )
worklist.push(m);
}
}
if( phi_cnt != end_idx() ) {
// did not schedule all. Retry, Bailout, or Die
Compile* C = matcher.C;
if (C->subsume_loads() == true && !C->failing()) {
// Retry with subsume_loads == false
// If this is the first failure, the sentinel string will "stick"
// to the Compile object, and the C2Compiler will see it and retry.
C->record_failure(C2Compiler::retry_no_subsuming_loads());
}
// assert( phi_cnt == end_idx(), "did not schedule all" );
return false;
}
#ifndef PRODUCT
if (cfg->trace_opto_pipelining()) {
tty->print_cr("#");
tty->print_cr("# after schedule_local");
for (uint i = 0;i < _nodes.size();i++) {
tty->print("# ");
_nodes[i]->fast_dump();
}
tty->cr();
}
#endif
return true;
}
//
// Load the D3DAPICalls benchmark report:
//
// benchmarkable_call_number,frame_time_ms,time_difference,call_type,draw_call_number,calls_skipped,calls_executed,ps_text,vs_text,vdecl_text
//
bool loadD3DAPICallsCSVFile(const char *name, const char *fname, const std::vector<std::string> &keywordTable, bool bDiffGraph, bool bCollapse)
{
char tmpstr[1024];
int graphDiff = -1;
std::ifstream fs(fname);
if(!fs.is_open())
{
if(g_pLog) g_pLog->AddMessage("no>>Failure...");
return false;
}
// for size of the file so we can display a progress bar
fs.seekg( -1, std::ios_base::end );
int bSize = (int)fs.tellg();
fs.seekg( 0, std::ios_base::beg );
g_pProgressBar->SetTitle("Loading D3DAPICalls benchmark data...");
if(g_pLog) g_pLog->AddMessage("Loading D3DAPICalls benchmark data %s", fname);
fs.getline(tmpstr, 1023); //Dummy line
if(*tmpstr == '\0')
{
if(g_pLog) g_pLog->AddMessage("no>>Failure...");
return false;
}
g_apiCall.clear();
int disp = (int)g_pDisplays.size();
IWindowFolding *pWFold;
if(disp == 0)
{
TLDisplay *pDisp = new TLDisplay(g_hwnd);
pDisp->name = "API Calls Benchmark";
g_pDisplays.push_back(pDisp);
//UI:
pWFold = g_pwinHandler->CreateWindowFolding((LPCSTR)(1<<16), "API Calls Benchmark", g_pMainContainer);
}
else
{
pWFold = (IWindowFolding *)g_pwinHandler->Get((LPCSTR)(1<<16))->QueryInterface("IWindowFolding");
}
// LET's ASSUME that this is always done in display #0 :
disp = 0;
int graphTime = g_pDisplays[disp]->addGraph(name);
//Create a second graph for time difference...
if(bDiffGraph)
{
TLDisplay *pDisp = new TLDisplay(g_hwnd);
pDisp->name = "API Calls time difference";
g_pDisplays.push_back(pDisp);
graphDiff = g_pDisplays[1]->addGraph(name);
}
//UI:
g_pwinHandler->CreateCtrlCheck((LPCSTR)graphTime, name, pWFold)->SetChecked(true);
//Examples:
//-1,2.40242,2.40242,first_call_was_skipped,,1999,0
//0,2.4076,0.005188,Clear,,1998,1
//Examples2:
//-1,2.10559,2.10559,first_call_was_skipped,,4147,0,,,
//0,2.42992,0.32433,Clear,,4146,1,,,
//2,2.66265,0.215147,Draw,0,4144,3,ps_ea97b1f6b1cbfb27_1,vs_text_1,vdecl_text_1
//Fill in the graph
Pattern::registerPattern("int", "\\s*([\\-0-9]*)\\s*");
Pattern::registerPattern("float", "\\s*([\\-0-9\\.eE]*)\\s*");
Pattern::registerPattern("text", "\\s*(\\w*)\\s*");
Pattern *p = Pattern::compile("{int},{float},{float},(\\w+),?{int},?{int},?{int},?{text},?{text},?{text}");
Matcher *m = p->createMatcher("");
int benchmarkable_call_number_collapsed = 0;
do {
int benchmarkable_call_number;
float frame_time_ms;
float time_difference;
std::string call_type;
int draw_call_number;
int calls_skipped;
int calls_executed;
std::string ps_text;
std::string vs_text;
std::string vdecl_text;
std::string comment;
fs.getline(tmpstr, 1023);
if(fs.eof())
break;
m->setString(tmpstr);
if(m->findFirstMatch())
{
benchmarkable_call_number = atoi(m->getGroup(1).c_str());
frame_time_ms = (float)atof(m->getGroup(2).c_str());
time_difference = (float)atof(m->getGroup(3).c_str());
call_type = m->getGroup(4);
draw_call_number = atoi(m->getGroup(5).c_str());
calls_skipped = atoi(m->getGroup(6).c_str());
calls_executed = atoi(m->getGroup(7).c_str());
ps_text = m->getGroup(8);
vs_text = m->getGroup(9);
vdecl_text = m->getGroup(10);
comment = m->getGroup(11);
for(int i=0; i< keywordTable.size(); i++)
{
if(call_type == keywordTable[i])
{
benchmarkable_call_number = -1;
break;
}
}
if((!fs.eof()) && (benchmarkable_call_number >= 0))
{
if(bCollapse)
benchmarkable_call_number = benchmarkable_call_number_collapsed;
if(bDiffGraph)
g_pDisplays[1]->addMeasure(graphDiff, TMeasure(time_difference, draw_call_number, call_type.c_str(), vs_text.c_str(), ps_text.c_str()), benchmarkable_call_number);
g_pDisplays[disp]->addMeasure(graphTime, TMeasure(frame_time_ms, draw_call_number, call_type.c_str(), vs_text.c_str(), ps_text.c_str()), benchmarkable_call_number);
if(call_type == "Clear")
{
g_pDisplays[disp]->setCommentForMeasure(graphTime, benchmarkable_call_number, call_type.c_str(), NULL, RGB(128,160,128));
}
if(call_type == "Draw")
{
g_apiCall.push_back(benchmarkable_call_number);
//assert((g_apiCall.size()-1) == draw_call_number);
}
/*if((call_type == "Lock")
||(call_type == "memcpy"))
{
g_pDisplays[disp]->setCommentForMeasure(graphTime, benchmarkable_call_number, NULL, NULL, RGB(128,160,128));
}*/
if(!comment.empty())
{
int i;
while((i=(int)comment.find_first_of("|")) >= 0)
{
comment.replace(i, 1,"\n");
}
g_pDisplays[disp]->Graphs[graphTime].Measures[benchmarkable_call_number].tooltipComments = comment;
}
benchmarkable_call_number_collapsed++;
}
}
else
{
assert(!"ERROR in parsing the line");
if(g_pLog) g_pLog->AddMessage("error>>Error in parsing a line");
}
if((benchmarkable_call_number % 200)==0)
g_pProgressBar->SetPercent((float)(100*fs.tellg()/bSize));
} while(!fs.eof());
if(g_pLog) g_pLog->AddMessage("yes>>Done");
return true;
}