void update(int64_t packet_raw, int packet_size, const Int64TimeField &packet_at, const string &filename) { LintelLogDebug("IPRolling::packet", format("UPD %d %d") % packet_raw % packet_size); if (!packets_in_flight.empty()) { int64_t cur_back_ts_raw = packets_in_flight.back().timestamp_raw; INVARIANT(packet_raw >= cur_back_ts_raw, format("out of order by %.4fs in %s; %d < %d") % packet_at.rawToDoubleSeconds(cur_back_ts_raw - packet_raw) % filename % packet_raw % cur_back_ts_raw); } while ((packet_raw - cur_time_raw) > interval_width_raw) { // update statistics for the interval from cur_time to cur_time + interval_width // all packets in p_i_f must have been received in that interval double bw = cur_bytes_in_queue * MiB_per_second_convert; MiB_per_second.add(bw); double pps = packets_in_flight.size() * kpackets_per_second_convert; kpackets_per_second.add(pps); LintelLogDebug("IPRolling::detail", format("[%d..%d[: %.0f, %d -> %.6g %.6g") % cur_time_raw % (cur_time_raw + update_step_raw) % cur_bytes_in_queue % packets_in_flight.size() % bw % pps); cur_time_raw += update_step_raw; while (! packets_in_flight.empty() && packets_in_flight.front().timestamp_raw < cur_time_raw) { cur_bytes_in_queue -= packets_in_flight.front().packetsize; packets_in_flight.pop_front(); } } packets_in_flight.push_back(packetTimeSize(packet_raw, packet_size)); cur_bytes_in_queue += packet_size; }
int main() { Deque <string> D; D.insertFront("Alice"); D.insertRear("Bob"); cout << D.front() << endl; cout << D.rear() << endl; cout << D.size() << endl; D.insertRear("Charlie"); cout << D.front() << endl; cout << D.rear() << endl; D.removeFront(); cout << D.front() << endl; cout << D.rear() << endl; cout << D.size() << endl; D.removeFront(); cout << D.size() << endl; }
void testNoDefaultConstructor() { Deque<NoDefaultConstructor> deque; deque.reserve(8); for(int i = 0; i < 5; ++i) { deque.push_back(NoDefaultConstructor(i)); SINVARIANT(deque.back().v == i); SINVARIANT(deque.size() == static_cast<size_t>(i + 1)); INVARIANT(NoDefaultConstructor::ndc_count == i + 1, format("%d != %d + 1") % NoDefaultConstructor::ndc_count % i); } for(int i = 0; i < 5; ++i) { SINVARIANT(deque.front().v == i); deque.pop_front(); deque.push_back(NoDefaultConstructor(i)); SINVARIANT(deque.back().v == i); SINVARIANT(deque.size() == 5); SINVARIANT(NoDefaultConstructor::ndc_count == 5); } for(int i = 0; i < 5; ++i) { SINVARIANT(deque.front().v == i); deque.pop_front(); SINVARIANT(deque.size() == static_cast<size_t>(4 - i)); SINVARIANT(NoDefaultConstructor::ndc_count == 4 - i); } SINVARIANT(NoDefaultConstructor::ndc_count == 0); }
void testPushBack() { Deque<int> deque; SINVARIANT(deque.empty()); deque.reserve(8); SINVARIANT(deque.empty() && deque.capacity() == 8); for(int i = 0; i < 5; ++i) { deque.push_back(i); SINVARIANT(deque.back() == i); SINVARIANT(deque.size() == static_cast<size_t>(i + 1)); } for(int i = 0; i < 5; ++i) { SINVARIANT(deque.at(i) == i); } for(int i = 0; i < 5; ++i) { SINVARIANT(deque.front() == i); deque.pop_front(); deque.push_back(i); SINVARIANT(deque.back() == i); SINVARIANT(deque.size() == 5); } for(int i = 0; i < 5; ++i) { SINVARIANT(deque.at(i) == i); } { Deque<int>::iterator i = deque.begin(); int j = 0; while(i != deque.end()) { INVARIANT(*i == j, format("%d != %d") % *i % j); ++i; ++j; } } vector<int> avec; for(int i = 5; i < 10; ++i) { avec.push_back(i); } deque.push_back(avec); for(int i = 0; i < 10; ++i) { SINVARIANT(deque.front() == i); deque.pop_front(); } SINVARIANT(deque.empty()); }
//--------------------Linear solution---------------------- void minimumValues(int v[], int k) { Deque<int> d = Deque<int>(); // In the queue I store positions, no elements for (int i = 0; i < N; i++) { if (i >= k) // Until we have not consider a subarray, we can not print the minimums. cout << v[d.front()] << " "; while (!d.empty() && v[d.back()] >= v[i]) { // While the queue is not empty and the element I want to insert is // greater or equal than the last one I extract the last element d.pop_back(); } d.push_back(i); // I insert the new element if (d.front() <= i - k) //This remove the minimum once is out of the subarray d.pop_front(); } cout << v[d.front()] << endl; }
void HyperDijkstra::visitAdjacencyMap(AdjacencyMap& amap, TreeAction* action, bool useDistance) { typedef std::deque<HyperGraph::Vertex*> Deque; Deque q; // scans for the vertices without the parent (whcih are the roots of the trees) and applies the action to them. for (AdjacencyMap::iterator it=amap.begin(); it!=amap.end(); ++it) { AdjacencyMapEntry& entry(it->second); if (! entry.parent()) { action->perform(it->first,0,0); q.push_back(it->first); } } //std::cerr << "q.size()" << q.size() << endl; int count=0; while (! q.empty()) { HyperGraph::Vertex* parent=q.front(); q.pop_front(); ++count; AdjacencyMap::iterator parentIt=amap.find(parent); if (parentIt==amap.end()) { continue; } //cerr << "parent= " << parent << " parent id= " << parent->id() << "\t children id ="; HyperGraph::VertexSet& childs(parentIt->second.children()); for (HyperGraph::VertexSet::iterator childsIt=childs.begin(); childsIt!=childs.end(); ++childsIt) { HyperGraph::Vertex* child=*childsIt; //cerr << child->id(); AdjacencyMap::iterator adjacencyIt=amap.find(child); assert (adjacencyIt!=amap.end()); HyperGraph::Edge* edge=adjacencyIt->second.edge(); assert(adjacencyIt->first==child); assert(adjacencyIt->second.child()==child); assert(adjacencyIt->second.parent()==parent); if (! useDistance) { action->perform(child, parent, edge); } else { action->perform(child, parent, edge, adjacencyIt->second.distance()); } q.push_back(child); } //cerr << endl; } }
void DequeTest() { Deque<int> testq; Deque<int> testBad(256); for(int i=0;i<512;i++) { testBad.push_back(i); } for(int i=0;i<512;i++) { INVARIANT(testBad.empty() == false && testBad.front() == i, "simple test failed?!"); testBad.pop_front(); } // test empty->size1->empty for(int size1=1;size1<2000;size1++) { INVARIANT(testq.empty()==true,"internal"); for(int j=0;j<size1;j++) { testq.push_back(j); INVARIANT(testq.empty()==false,"internal"); } for(int j=0;j<size1;j++) { INVARIANT(testq.empty()==false,"internal"); INVARIANT(testq.front() == j, boost::format("Internal Error: %d/%d") % size1 % j); testq.pop_front(); } INVARIANT(testq.empty()==true,"internal"); } printf("pass empty->full->empty tests\n"); // test empty->size1, size2 add/remove, ->empty for(int size1=1;size1<150;size1++) { for(int size2=1;size2<400;size2++) { INVARIANT(testq.empty()==true,"internal"); for(int j=0;j<size1;j++) { testq.push_back(j); INVARIANT(testq.empty()==false,"internal"); } for(int j=0;j<size2;j++) { INVARIANT(testq.empty()==false,"internal"); INVARIANT(testq.front() == j, boost::format("Internal Error: %d/%d/%d") % size1 % size2 %j); testq.pop_front(); testq.push_back((j+size1)); } for(int j=size2;j<size1+size2;j++) { INVARIANT(testq.empty()==false,"internal"); int t = testq.front(); testq.pop_front(); INVARIANT(t == j, boost::format("Internal Error: %d/%d/%d/%d") % t % size1 % size2 % j); } INVARIANT(testq.empty()==true,"internal"); } } printf("pass partial fill tests\n"); }