/** Get list of not-persistent qi */
public ArrayList<QI> getList() {
ArrayList<QI> result = new ArrayList<QI>();
for (ArrayList<QI> list : _map.values()) {
for (QI qi : list) {
if (qi.get_id() == QI.NOT_PERSISTENT) result.add(qi);
}
}
return result;
}
/** Contains such quantum invariant? */
public boolean contains(QI qi) {
long hashCode = qi.getHashCode();
ArrayList<QI> list = _map.get(hashCode);
if (list == null) {
return false;
} else {
for (QI aux : list) {
if (aux.isEqual(qi)) return true;
}
return false;
}
}
/** Returns null if the qi is new to the repository otherwise returns the already stored QI */
public synchronized QI add(QI qi) {
long hashCode = qi.getHashCode();
ArrayList<QI> list = _map.get(hashCode);
if (list == null) {
list = new ArrayList<QI>();
_map.put(hashCode, list);
list.add(qi);
return null;
} else {
for (QI aux : list) {
if (aux.isEqual(qi)) return aux;
}
list.add(qi);
return null;
}
}
@Before
public void setUp() throws Exception {
shapeHelperWrapper = Mockito.mock(ShapeHelperWrapper.class, "shapeHelperWrapper");
unoRuntimeWrapper = Mockito.mock(UnoRuntimeWrapper.class, "unoRuntimeWrapper");
Injector injector = Guice.createInjector(new TestModule(shapeHelperWrapper, unoRuntimeWrapper));
QI.setUnoRuntimeWrapper(unoRuntimeWrapper);
diagramWalker = injector.getInstance(DiagramWalker.class);
}
public void serve() {
long startTime, endTime;
try {
// query = (query)incomingPeer.receive();
startTime = (new Date()).getTime();
queryLiteral = query.getLiteral();
inheritedHistory = (LinkedList) query.getHistory();
inheritedSupportingRules = query.getSupportingMappings();
inheritedConflictingRules = query.getConflictingMappings();
System.out.println("\n\n |||||| New query session ||||||\n");
System.out.println("\tLocal reasoning for: " + queryLiteral.getSignWithName());
/*
if((cachedAnswer=incQueriesCache.getAnswerForLiteral(queryLiteral))!=null)
{
System.out.println(" is already cached: " + ((MyBoolean)cachedAnswer.getAnswer()).getMyBoolean() );
if(queryLiteral.getSign()==true)
incomingPeer.send(new QueryResponse(cachedAnswer.getAnswer(), cachedAnswer.getSet(), null));
else
incomingPeer.send(new QueryResponse(cachedAnswer.getAnswer(), null, cachedAnswer.getSet()));
return;
}
*/
System.out.println("you are querying about: " + queryLiteral);
if (kb.isRuleInside(KnowledgeBase.localSetName, queryLiteral)) {
System.out.println("First Step");
localAnswer = new MyBoolean(false);
System.out.println("Sec Step");
currLocalHistory.add(queryLiteral);
System.out.println("third Step");
local_alg(queryLiteral, currLocalHistory, localAnswer);
System.out.println("4 Step");
if (localAnswer.getMyBoolean()) {
System.out.println("local true");
System.out.println(" Answer: " + localAnswer.getMyBoolean());
// incQueriesCache.rememberLiteral(queryLiteral, localAnswer, null);
System.out.println("Result Answer: " + localAnswer.getMyBoolean());
QI.sendResults(new QueryResponse(query, localAnswer, null, null), this.processID);
return;
}
}
System.out.println("reverse Step");
queryLiteral.reverseSign();
if (kb.isRuleInside("L", queryLiteral)) {
System.out.println("inside1 Step");
localAnswer = new MyBoolean(false);
currLocalHistory.clear();
currLocalHistory.add(queryLiteral);
local_alg(queryLiteral, currLocalHistory, localAnswer);
if (localAnswer.getMyBoolean()) {
localAnswer.setMyBoolean(false);
queryLiteral.reverseSign();
System.out.println("inside2 Step");
// incQueriesCache.rememberLiteral(queryLiteral, localAnswer, null);
QI.sendResults(new QueryResponse(query, localAnswer, null, null), this.processID);
return;
}
}
// VERIFIED TILL HERE
queryLiteral.reverseSign();
System.out.println("reverse1 Step");
////////////////////////////////////////////////////////////////////////
////////////// distributed reasoning for supporting rules //////////////
rulesCollection = (Collection) kb.getSupportingRulesByHeadLiteral(queryLiteral);
rules = rulesCollection.iterator();
System.out.println(
"\n\n\tReasoning for support of literal: " + queryLiteral.getSignWithName());
while (rules.hasNext()) {
flag = false;
supportingRules = new LinkedList();
rule = (Rule) rules.next();
body = rule.getBody();
bequeathHistory = new LinkedList(inheritedHistory);
while (body.hasNext()) {
literal = (Literal) body.next();
if (inheritedHistory.contains(literal.getSignWithName())) {
flag = true;
break;
} else {
uniteSets(bequeathHistory, inheritedHistory);
bequeathHistory.add(literal.getSignWithName());
suppForLiteral = new LinkedList();
conflForLiteral = new LinkedList();
System.out.println(
"\tRequesting literal: "
+ literal.getSignWithName()
+ " from: "
+ literal.getLocation()
+ "\n");
boolean local = false;
if (literal.getLocation().equals("local")
|| literal.getLocation().equals(this.QI.getName())) local = true;
Query q;
if (local) {
q =
new Query(
this.QI.getName(),
this.processID,
false,
this.QI.getName(),
literal,
false,
suppForLiteral,
conflForLiteral,
bequeathHistory);
QI.incomingQuery(q);
// QI.sendQueryToPeer(q);//to test
} else {
q =
new Query(
this.QI.getName(),
this.processID,
false,
literal.getLocation(),
literal,
false,
suppForLiteral,
conflForLiteral,
bequeathHistory);
QI.sendQueryToPeer(q);
}
queryResponse = this.dr.take();
if (queryResponse.getReturnValue() == false) {
flag = true;
break;
} else if (queryResponse.getReturnValue() == true
&& (kb.isLocalLiteralInside(literal) == false)) supportingRules.add(literal);
else {
supportingRules =
(LinkedList) uniteSets(supportingRules, queryResponse.getSupportingSet());
}
// outQueriesCache.rememberLiteral(literal, new
// MyBoolean(queryResponse.getReturnValue()), supportingRules);
}
}
if (flag == true) continue;
else handleSupportingSet();
}
if (inheritedSupportingRules.size() == 0) {
System.out.println("Sending results");
// incQueriesCache.rememberLiteral(queryLiteral, new MyBoolean(false), null);
this.QI.sendResults(
new QueryResponse(query, new MyBoolean(false), null, null), this.processID);
return;
}
/////////////////////////////////////////////////////////////////////////
////////////// distributed reasoning for conflicting rules //////////////
rulesCollection = (Collection) kb.getConflictingRulesByHeadLiteral(queryLiteral);
rules = rulesCollection.iterator();
System.out.println(
"\tReasoning for conflicts for literal: " + queryLiteral.getSignWithName());
while (rules.hasNext()) {
flag = false;
supportingRules = new LinkedList();
rule = (Rule) rules.next();
body = rule.getBody();
bequeathHistory = new LinkedList(inheritedHistory);
while (body.hasNext()) {
literal = (Literal) body.next();
if (inheritedHistory.contains(literal.getSignWithName())) {
flag = true;
break;
} else {
uniteSets(bequeathHistory, inheritedHistory);
bequeathHistory.add(literal.getSignWithName());
// findPeerMessage = adhoc.findPeer(literal.getLocation(), this.groupName);
// outcomingPeer = new Peer(literal.getLocation(), findPeerMessage.getIPAddress(),
// findPeerMessage.getPort());
suppForLiteral = new LinkedList();
conflForLiteral = new LinkedList();
System.out.println(
"\tRequesting literal: "
+ literal.getSignWithName()
+ " from: "
+ literal.getLocation()
+ "\n");
Query q =
new Query(
this.QI.getName(),
this.processID,
false,
literal.getLocation(),
literal,
false,
suppForLiteral,
conflForLiteral,
bequeathHistory);
QI.sendQueryToPeer(q);
queryResponse = this.dr.take();
if (queryResponse.getReturnValue() == false) {
flag = true;
break;
} else if (queryResponse.getReturnValue() == true
&& (kb.isLocalLiteralInside(literal) == false)) supportingRules.add(literal);
else
supportingRules =
(LinkedList) uniteSets(supportingRules, queryResponse.getSupportingSet());
// outQueriesCache.rememberLiteral(literal, new
// MyBoolean(queryResponse.getReturnValue()), supportingRules);
}
}
if (flag == true) continue;
else handleConflictingSet();
}
endTime = (new Date()).getTime();
System.out.println("\n Time taken: " + (endTime - startTime));
if (inheritedConflictingRules.size() == 0) {
// incQueriesCache.rememberLiteral(queryLiteral, new MyBoolean(true),
// inheritedSupportingRules);
this.QI.sendResults(
new QueryResponse(query, new MyBoolean(true), inheritedSupportingRules, null),
this.processID);
return;
}
resolveConflicts();
return;
} catch (Throwable t) {
t.printStackTrace();
this.QI.notifyFailure(query, processID);
}
}
public static void main(String[] args)
throws FileNotFoundException, IOException, SQLException, ClassNotFoundException {
// Args: Limit / numThreads / numedges / qiIDPrefix
int numThreads = 16;
if (args.length >= 2) {
numThreads = Integer.parseInt(args[1]);
}
BlinkBuffer blinkBuffer = new BlinkBuffer();
QICalculator[] threads = new QICalculator[numThreads];
int numedges = 0;
if (args.length >= 3) {
numedges = Integer.parseInt(args[2]);
}
long qiIDPrefix = 0;
if (args.length >= 4) {
qiIDPrefix = Integer.parseInt(args[3]);
}
BlinkDB db = (BlinkDB) App.getRepositorio();
long t0 = System.currentTimeMillis();
QIRepository R = new QIRepository();
// fill in QIRepository
ArrayList<QI> qis = App.getRepositorio().getQIs();
for (QI q : qis) R.add(q);
HashMap<BlinkEntry, QI> _map = new HashMap<BlinkEntry, QI>();
int limit = Integer.parseInt(args[0]);
long blinkIDs[] = db.getBlinkIDsWithoutQI(limit, numedges);
System.out.println("Found " + blinkIDs.length + " blinks without QI");
int delta = 100;
int count = 1;
int acum = 0;
for (int k = 0; k < blinkIDs.length; k += delta) {
long t = System.currentTimeMillis();
long[] curIDs = Arrays.copyOfRange(blinkIDs, k, Math.min(k + delta, blinkIDs.length));
System.out.print("Calc for ");
for (long x : curIDs) {
System.out.print(" " + x);
}
System.out.println("");
ArrayList<BlinkEntry> bs = db.getBlinksByIDsArray(curIDs);
t = System.currentTimeMillis();
blinkBuffer.reset(bs);
for (int i = 0; i < numThreads; ++i) {
threads[i] = new QICalculator(blinkBuffer);
threads[i].start();
}
try {
for (int i = 0; i < numThreads; ++i) {
threads[i].join();
}
} catch (InterruptedException e) {
System.out.println("Problem!");
}
System.out.println(String.format(" %.2f sec.", (System.currentTimeMillis() - t) / 1000.0));
for (int i = 0; i < bs.size(); ++i) {
BlinkEntry be = bs.get(i);
QI qi = blinkBuffer.qis[i];
// add to repository
QI qiRep = R.add(qi);
if (qiRep == null) qiRep = qi;
//
_map.put(be, qiRep);
}
//
ArrayList<QI> list = R.getList(); // get list of not persistent QIs
// t = System.currentTimeMillis();
db.insertQIs(list, qiIDPrefix);
acum = acum + list.size();
System.out.println(
String.format(
"Inserted %6d new QIs total QIs %6d in %.2f sec.",
list.size(), acum, (System.currentTimeMillis() - t0) / 1000.0));
// updating biEntry
for (BlinkEntry be : bs) {
QI qi = _map.get(be);
be.set_qi(qi.get_id());
}
// update qis
t = System.currentTimeMillis();
db.updateBlinksQI(bs);
// System.out.println(String.format("Updated QIs %d blinks in %.2f sec.", bs.size(),
// (System.currentTimeMillis() - t) / 1000.0));
// update index
System.out.println(
"Calculated " + (k + curIDs.length) + " of " + blinkIDs.length + " blinks QI");
}
System.out.println(
String.format(
"Total Time to calculate QIs %.2f sec.", (System.currentTimeMillis() - t0) / 1000.0));
System.exit(0);
}
