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;
}
