/*! creates a hardware thread running on specific core */ thread_t createThread(thread_func f, void* arg, size_t stack_size, ssize_t threadID) { #ifdef __MIC__ threadID++; // start counting at 1 on MIC #endif /* set stack size */ pthread_attr_t attr; pthread_attr_init(&attr); if (stack_size > 0) pthread_attr_setstacksize (&attr, stack_size); /* create thread */ pthread_t* tid = new pthread_t; if (pthread_create(tid,&attr,(void*(*)(void*))threadStartup,new ThreadStartupData(f,arg,threadID)) != 0) THROW_RUNTIME_ERROR("pthread_create"); /* attempt to set affinity */ #if defined(__LINUX__) if (threadID >= 0) { cpu_set_t cset; CPU_ZERO(&cset); CPU_SET(threadID, &cset); pthread_setaffinity_np(*tid,sizeof(cpu_set_t),&cset); } #endif return thread_t(tid); }
/*! creates a hardware thread running on specific core */ thread_t createThread(thread_func f, void* arg, size_t stack_size, ssize_t threadID) { HANDLE thread = CreateThread(nullptr, stack_size, (LPTHREAD_START_ROUTINE)threadStartup, new ThreadStartupData(f,arg), 0, nullptr); if (thread == nullptr) FATAL("CreateThread failed"); if (threadID >= 0) setAffinity(thread, threadID); return thread_t(thread); }
/*! creates a hardware thread running on specific core */ thread_t createThread(thread_func f, void* arg, size_t stack_size, ssize_t threadID) { HANDLE thread = CreateThread(NULL, stack_size, (LPTHREAD_START_ROUTINE)threadStartup, new ThreadStartupData(f,arg), 0, NULL); if (thread == NULL) THROW_RUNTIME_ERROR("cannot create thread"); if (threadID >= 0) setAffinity(thread, threadID); return thread_t(thread); }
/*! creates a hardware thread running on specific core */ thread_t createThread(thread_func f, void* arg, size_t stack_size, ssize_t threadID) { /* set stack size */ pthread_attr_t attr; pthread_attr_init(&attr); if (stack_size > 0) pthread_attr_setstacksize (&attr, stack_size); /* set affinity */ #if defined(__LINUX__) if (threadID >= 0) { cpu_set_t cset; CPU_ZERO(&cset); CPU_SET(threadID, &cset); pthread_attr_setaffinity_np(&attr,sizeof(cpu_set_t),&cset); } #endif /* create thread */ pthread_t* tid = new pthread_t; if (pthread_create(tid,&attr,(void*(*)(void*))threadStartup,new ThreadStartupData(f,arg,threadID)) != 0) throw std::runtime_error("pthread_create"); return thread_t(tid); }
s32 cellMsgDialogOpen2(u32 type, vm::cptr<char> msgString, vm::ptr<CellMsgDialogCallback> callback, vm::ptr<void> userData, vm::ptr<void> extParam) { cellSysutil.Warning("cellMsgDialogOpen2(type=0x%x, msgString=*0x%x, callback=*0x%x, userData=*0x%x, extParam=*0x%x)", type, msgString, callback, userData, extParam); if (!msgString || strlen(msgString.get_ptr()) >= 0x200 || type & -0x33f8) { return CELL_MSGDIALOG_ERROR_PARAM; } switch (type & CELL_MSGDIALOG_TYPE_BUTTON_TYPE) { case CELL_MSGDIALOG_TYPE_BUTTON_TYPE_NONE: { if (type & CELL_MSGDIALOG_TYPE_DEFAULT_CURSOR) { return CELL_MSGDIALOG_ERROR_PARAM; } switch (type & CELL_MSGDIALOG_TYPE_PROGRESSBAR) { case CELL_MSGDIALOG_TYPE_PROGRESSBAR_NONE: break; case CELL_MSGDIALOG_TYPE_PROGRESSBAR_SINGLE: break; case CELL_MSGDIALOG_TYPE_PROGRESSBAR_DOUBLE: break; default: return CELL_MSGDIALOG_ERROR_PARAM; } break; } case CELL_MSGDIALOG_TYPE_BUTTON_TYPE_YESNO: { switch (type & CELL_MSGDIALOG_TYPE_DEFAULT_CURSOR) { case CELL_MSGDIALOG_TYPE_DEFAULT_CURSOR_YES: break; case CELL_MSGDIALOG_TYPE_DEFAULT_CURSOR_NO: break; default: return CELL_MSGDIALOG_ERROR_PARAM; } if (type & CELL_MSGDIALOG_TYPE_PROGRESSBAR) { return CELL_MSGDIALOG_ERROR_PARAM; } break; } case CELL_MSGDIALOG_TYPE_BUTTON_TYPE_OK: { if (type & CELL_MSGDIALOG_TYPE_DEFAULT_CURSOR) { return CELL_MSGDIALOG_ERROR_PARAM; } if (type & CELL_MSGDIALOG_TYPE_PROGRESSBAR) { return CELL_MSGDIALOG_ERROR_PARAM; } break; } default: return CELL_MSGDIALOG_ERROR_PARAM; } MsgDialogState old = msgDialogNone; if (!g_msg_dialog->state.compare_exchange_strong(old, msgDialogInit)) { return CELL_SYSUTIL_ERROR_BUSY; } g_msg_dialog->wait_until = get_system_time() + 31536000000000ull; // some big value switch (type & CELL_MSGDIALOG_TYPE_PROGRESSBAR) { case CELL_MSGDIALOG_TYPE_PROGRESSBAR_DOUBLE: g_msg_dialog->progress_bar_count = 2; break; case CELL_MSGDIALOG_TYPE_PROGRESSBAR_SINGLE: g_msg_dialog->progress_bar_count = 1; break; default: g_msg_dialog->progress_bar_count = 0; break; } switch (type & CELL_MSGDIALOG_TYPE_SE_MUTE) // TODO { case CELL_MSGDIALOG_TYPE_SE_MUTE_OFF: break; case CELL_MSGDIALOG_TYPE_SE_MUTE_ON: break; } std::string msg = msgString.get_ptr(); switch (type & CELL_MSGDIALOG_TYPE_SE_TYPE) { case CELL_MSGDIALOG_TYPE_SE_TYPE_NORMAL: cellSysutil.Warning("%s", msg); break; case CELL_MSGDIALOG_TYPE_SE_TYPE_ERROR: cellSysutil.Error("%s", msg); break; } g_msg_dialog->status = CELL_MSGDIALOG_BUTTON_NONE; CallAfter([type, msg]() { if (Emu.IsStopped()) { g_msg_dialog->state.exchange(msgDialogNone); return; } g_msg_dialog->Create(type, msg); g_msg_dialog->state.exchange(msgDialogOpen); }); while (g_msg_dialog->state == msgDialogInit) { if (Emu.IsStopped()) { if (g_msg_dialog->state != msgDialogNone) { break; } CHECK_EMU_STATUS; } std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack } thread_t(WRAP_EXPR("MsgDialog Thread"), [=]() { while (g_msg_dialog->state == msgDialogOpen || (s64)(get_system_time() - g_msg_dialog->wait_until) < 0) { if (Emu.IsStopped()) { g_msg_dialog->state = msgDialogAbort; break; } std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack } if (callback && g_msg_dialog->state != msgDialogAbort) { const s32 status = g_msg_dialog->status; Emu.GetCallbackManager().Register([=](CPUThread& CPU) -> s32 { callback(static_cast<PPUThread&>(CPU), status, userData); return CELL_OK; }); } CallAfter([]() { g_msg_dialog->Destroy(); g_msg_dialog->state = msgDialogNone; }); }).detach(); return CELL_OK; }
void Thread::start() { this->thread = thread_t(&Thread::run, this); }
void AssignThreadsAlgorithm::apply(Stream& stream) { const std::vector<Operator*> & operators = stream.initializedOperators(); if (operators.size() == 0) return; // create the graph Graph graph; std::map<const Operator*, Graph::vertex_descriptor> op2VertexMap; // fill the maps for(std::vector<Operator*>::const_iterator op = operators.begin(); op != operators.end(); ++op) { Graph::vertex_descriptor v = boost::add_vertex(graph); boost::put(operator_t(), graph, v, *op); op2VertexMap[*op] = v; } // iterate over each operator for(std::vector<Operator*>::const_iterator op = operators.begin(); op != operators.end(); ++op) { const std::vector<const Description*> & inputs = (*op)->info().inputs(); for(std::vector<const Description*>::const_iterator input = inputs.begin(); input != inputs.end(); ++input) { Output connector = stream.connectionSource(*op, (*input)->id()); if(connector.valid()) { const Operator* source = connector.op(); const Operator* target = *op; const Description& output = source->info().output(connector.id()); Graph::edge_descriptor e = boost::add_edge(op2VertexMap[source], op2VertexMap[target], graph).first; std::map<Graph::vertex_descriptor, int> operatorThreads; operatorThreads[op2VertexMap[source]] = output.operatorThread(); operatorThreads[op2VertexMap[target]] = (*input)->operatorThread(); boost::put(operator_thread_t(), graph, e, operatorThreads); boost::put(thread_t(), graph, e, NO_THREAD); boost::put(connector_id_t(), graph, e, (*input)->id()); } } } int numThreads = 0; Visitor v(numThreads); boost::undirected_dfs<>(graph, root_vertex(Graph::vertex_descriptor(0)).visitor(v) .edge_color_map(get(edge_color, graph))); // delete all threads while(stream.threads().size()) stream.removeThread(stream.threads().front()); // create threads for (int i = 0; i < numThreads; ++i) stream.addThread(); // add the inputs to the threads graph_traits<Graph>::edge_iterator ei, ei_end; for (boost::tie(ei, ei_end) = edges(graph); ei != ei_end; ++ei) { int thread = boost::get(thread_t(), graph, *ei); if (thread == NO_THREAD) continue; unsigned int id = boost::get(connector_id_t(), graph, *ei); Graph::vertex_descriptor v = boost::target(*ei, graph); Operator* op = boost::get(operator_t(), graph, v); stream.threads()[thread]->addInput(op, id); } }