void test_iter(Test* test) { SList* list = new SList("hello","wordl"); list->push_back("hi"); list->push_back("why"); for(SList_iterator it = list->begin();it!=list->end();it++) std::cout<<(*it).get_stringi()<<endl; delete list; }
void testSList() { SList list; list.push_front("Alice"); list.push_front("Bob"); list.push_front("Copernicus"); for (SList::ConstIterator cit = list.begin(); cit != list.end(); ++cit) { std::cout << *cit << std::endl; } std::cout << std::endl; for (SList::Iterator it = list.begin(); it != list.end(); ++it) { std::cout << *it << std::endl; } std::cout << std::endl; }
int main(void){ SList<int> mylist; mylist.pushFront(10); mylist.pushFront(20); mylist.pushBack(30); for(auto it=mylist.begin();it!=mylist.end();++it){ cout << *it << endl; } return 0; }
int main() { SList<int> intList; POSITION p1=intList.push_back(1); POSITION p2=intList.push_back(2); POSITION p3=intList.push_back(3); POSITION p4=intList.push_back(4); POSITION p5=intList.push_back(5); for(POSITION p=intList.start(); p != 0 ;p=intList.next(p)) //A != operátort end()-re nem tudta értelmezni így helyette 0-t írtam { cout<<intList.getAt(p)<<endl; } cout<<"Remove: "<<intList.remove(p2)<<endl; cout<<"Remove: "<<intList.remove(p1)<<endl; cout<<"Remove: "<<intList.remove(p5)<<endl; cout<<"Remove: "<<intList.remove(p3)<<endl; intList.insert_after(p4,10); intList.insert_after(p4,11); for(POSITION p2=intList.start();p2 != 0; p2= intList.next(p2)) //A != operátort end()-re nem tudta értelmezni így helyette 0-t írtam { cout<<intList.getAt(p2)<<endl; } cout << "iteratorral:\n"; for(SList<int>::iterator it = intList.begin(); it != intList.end(); ++it) cout << *it << " "; cout << endl; SList<int> intList_2 = intList.reverse(); //A reverse függvény értelmetlen lenne másoló kontruktor használata nélkül //A konstokat pedig iterátor használat céljából távolítottuk el. cout << "A forditott lista: "; for(SList<int>::iterator it = intList_2.begin(); it != intList_2.end(); ++it) cout << *it << " "; cout << endl; SList<int> intList_3 = intList.concatenate(intList_2); //A concatenate tesztelése cout << "Az eredeti es a forditott lista osszefuzese: "; for(SList<int>::iterator it = intList_3.begin(); it != intList_3.end(); ++it) cout << *it << " "; cout << endl; getchar(); return 0; }
int main(void){ SList<int> list; SList<int>::iterator i; list.insert(5); list.insert(6); list.insert(1); list.insert(2); // list.append(10); // list.rmFirst(); // list.rmLast(); for(i=list.begin();i!=list.end();i++){ cout << *i << endl; } for(i=list.begin();i!=list.end();i++){ *i = *i + 1; } for(i=list.begin();i!=list.end();i++){ cout << *i << endl; } }
uint32_t Scheduler::Run() { ThreadLocalInfo& info = GetLocalInfo(); info.current_task = NULL; uint32_t do_max_count = runnale_task_count_; uint32_t do_count = 0; Debug("Run --------------------------"); // 每次Run执行的协程数量不能多于当前runnable协程数量 // 以防wait状态的协程得不到执行。 while (do_count < do_max_count) { uint32_t cnt = std::max((uint32_t)1, std::min( do_max_count / GetOptions().chunk_count, GetOptions().max_chunk_size)); Debug("want pop %u tasks.", cnt); SList<Task> slist = run_task_.pop(cnt); Debug("really pop %u tasks.", cnt); if (slist.empty()) break; SList<Task>::iterator it = slist.begin(); while (it != slist.end()) { Task* tk = &*it; info.current_task = tk; Debug("enter task(%llu)", tk->id_); swapcontext(&info.scheduler, &tk->ctx_); ++do_count; Debug("exit task(%llu) state=%d", tk->id_, tk->state_); info.current_task = NULL; switch (tk->state_) { case TaskState::runnable: ++it; break; case TaskState::io_block: case TaskState::sync_block: --runnale_task_count_; it = slist.erase(it); wait_task_.push(tk); break; case TaskState::done: default: --task_count_; --runnale_task_count_; it = slist.erase(it); delete tk; break; } } Debug("push %d task return to runnable list", slist.size()); run_task_.push(slist); } static thread_local epoll_event evs[1024]; int n = epoll_wait(epoll_fd, evs, 1024, 1); Debug("do_count=%u, do epoll event, n = %d", do_count, n); for (int i = 0; i < n; ++i) { Task* tk = (Task*)evs[i].data.ptr; if (tk->unlink()) AddTask(tk); } return do_count; }
uint32_t Processer::Run(ThreadLocalInfo &info, uint32_t &done_count) { info.current_task = NULL; done_count = 0; uint32_t c = 0; SList<Task> slist = runnable_list_.pop_all(); uint32_t do_count = slist.size(); DebugPrint(dbg_scheduler, "Run [Proc(%d) do_count:%u] --------------------------", id_, do_count); SList<Task>::iterator it = slist.begin(); for (; it != slist.end(); ++c) { Task* tk = &*it; info.current_task = tk; tk->state_ = TaskState::runnable; DebugPrint(dbg_switch, "enter task(%s)", tk->DebugInfo()); RestoreStack(tk); int ret = swapcontext(&info.scheduler, &tk->ctx_); if (ret) { fprintf(stderr, "swapcontext error:%s\n", strerror(errno)); runnable_list_.push(tk); ThrowError(eCoErrorCode::ec_swapcontext_failed); } DebugPrint(dbg_switch, "leave task(%s) state=%d", tk->DebugInfo(), tk->state_); info.current_task = NULL; switch (tk->state_) { case TaskState::runnable: ++it; break; case TaskState::io_block: it = slist.erase(it); g_Scheduler.io_wait_.SchedulerSwitch(tk); break; case TaskState::sleep: it = slist.erase(it); g_Scheduler.sleep_wait_.SchedulerSwitch(tk); break; case TaskState::sys_block: case TaskState::user_block: { if (tk->block_) { it = slist.erase(it); if (!tk->block_->AddWaitTask(tk)) runnable_list_.push(tk); tk->block_ = NULL; } else { std::unique_lock<LFLock> lock(g_Scheduler.user_wait_lock_); auto &zone = g_Scheduler.user_wait_tasks_[tk->user_wait_type_]; auto &wait_pair = zone[tk->user_wait_id_]; auto &task_queue = wait_pair.second; if (wait_pair.first) { --wait_pair.first; tk->state_ = TaskState::runnable; ++it; } else { it = slist.erase(it); task_queue.push(tk); } g_Scheduler.ClearWaitPairWithoutLock(tk->user_wait_type_, tk->user_wait_id_, zone, wait_pair); } } break; case TaskState::done: default: --task_count_; ++done_count; it = slist.erase(it); DebugPrint(dbg_task, "task(%s) done.", tk->DebugInfo()); if (tk->eptr_) { std::exception_ptr ep = tk->eptr_; runnable_list_.push(slist); tk->DecrementRef(); std::rethrow_exception(ep); } else tk->DecrementRef(); break; } } if (do_count) runnable_list_.push(slist); return c; }