void SeessionID::push_back(const std::string & sid, const std::string str) {
WriteLock w_lock(myLock);
std::vector<std::string> value;
boost::regex regex1(" ", boost::regbase::normal | boost::regbase::icase);
std::string mstr = str;
boost::regex_split(std::back_inserter(value), mstr, regex1);
for (int i = 0; i < (int) value.size(); i++) {
if (!value[i].empty()) {
if (ptrsmap[sid].ptr_s.empty()) {
ptrsmap[sid].ptr_s.push_back(value[i]);
} else {
bool find = false;
for (unsigned int j = 0; j < ptrsmap[sid].ptr_s.size(); j++) {
if (ptrsmap[sid].ptr_s[j] == value[i]) {
find = true;
break;
}
}
if (!find) {
ptrsmap[sid].ptr_s.push_back(value[i]);
}
}
}
}
}
void SeessionID::WriteFunction(std::string msg) {
WriteLock w_lock(myLock);
//保留2000条消息，删除最早的1000条
if (mmap.size() > 2000) {
mmap.erase(mmap.begin(),mmap.begin()+1000);
}
msgstruct_ptr smsg(new msgstruct());
smsg->i = kki;
smsg->msg = msg;
mmap.push_back(smsg);
kki = kki + 1;
}
void CQuoteAggregator::SubscribeQuotes( CQuoteListener* pQuoteListener )
{
assert(pQuoteListener != NULL);
WriteLock w_lock(m_lock);
// know which symbols to subscribe
vector<string>& regSymbols = pQuoteListener->GetSymbols();
BOOST_FOREACH( const string& symb, regSymbols )
{
// add it to listener map
m_symbolListeners.insert(make_pair(symb, pQuoteListener));
}
void phantom_dump_windows_buf(char *bp, int len)
{
drv_video_window_t *w;
w_lock();
queue_iterate(&allwindows, w, drv_video_window_t *, chain)
{
int pn = snprintf( bp, len, "%s%3dx%3d @%3dx%3d z %2d fl%b st%b %s%.10s\x1b[37m\n",
(w->state & WSTATE_WIN_FOCUSED) ? "\x1b[32m" : "",
w->xsize, w->ysize, w->x, w->y, w->z,
w->flags, "\020\01Decor\02!InAll\03NoFocus\04!Pixels\05!Opaq\06OnTop",
w->state, "\020\01Focused\02Dragged\03Visible\04Rolled\010Uncov\011InFB",
(w->stall ? "STALL " : ""),
//w->events_count, w->owner,
(w->title ? w->title : "??")
);
len -= pn;
bp += pn;
}
w_unlock();
}
void w_event_deliver_thread(void)
{
hal_sem_init( &we_sem, "wevent" );
we_inited = 1;
hal_set_thread_name("WEvent");
hal_set_current_thread_priority(PHANTOM_SYS_THREAD_PRIO+1);
while(1)
{
hal_sem_acquire( &we_sem ); // TODO need some 'acquire_all' method to eat all releases
restart:
w_lock();
window_handle_t w;
queue_iterate_back(&allwindows, w, drv_video_window_t *, chain)
{
if( w->events_count )
{
if(w->eventDeliverSema)
hal_sem_release(w->eventDeliverSema);
if(w->inKernelEventProcess)
{
w_unlock();
w_do_deliver_event(w);
goto restart;
}
}
}
w_unlock();
}
}
int run(cpu_cmds* cmds) {
int i;
struct sched_param param;
//cpu_cmds* cmds;
//cmds = parse_cpus(argc, argv);
if (!cmds) {
ERROR(finish);
}
if (pthread_barrier_init(&barrier, NULL, cmds->cpus)) {
printf("Could not initialize barrier.\n");
ERROR(cmds_free);
}
if (signal(SIGINT, handler) == SIG_ERR || signal(SIGTERM, handler) == SIG_ERR) {
printf("Signal handler could not be established.\n");
ERROR(barrier_free);
}
sync_barrier = getInteger("sync", 1); /* sync by default */
for (i=1; i < cmds->cpus; i++) {
if (cmds->ratios[i].ratio != cmds->ratios[0].ratio) {
printf("All CPUs must have the same ratio.\n");
ERROR(barrier_free);
}
}
ratio = cmds->ratios[0].ratio;
printf("Syncing: %s\n", (sync_barrier) ? "on" : "off");
printf("Interval: %lld\n", cmds->interval);
printf("Cpufreq use: %s\n",cmds->cpufreq ? "yes" : "no");
for (i=0; i < cmds->cpus; i++) {
printf("CPU %d ratio = %.3f\n", cmds->ratios[i].cpu, cmds->ratios[i].ratio);
}
/* go realtime */
param.sched_priority = sched_get_priority_max(SCHED_FIFO);
if (pthread_setschedparam(pthread_self(), SCHED_FIFO, ¶m)) {
printf("Bloke! I wanna go pro but I can't! :)\n");
ERROR(barrier_free);
}
/* calibrate */
loops_per_sec = CALIBRATE(LOOP(), 1.0);
printf("# loops per second = %lld\n", loops_per_sec);
threads = (pthread_t*)malloc(sizeof(pthread_t) * cmds->cpus);
if (!threads) {
printf("Could not allocate threads.\n");
ERROR(barrier_free);
}
for (i=0; i < cmds->cpus; i++) {
cpu_set_t cpuset;
param.sched_priority = sched_get_priority_max(SCHED_FIFO);
if (pthread_create(&threads[i], NULL, thread_fn, (void*)&cmds->interval)) {
printf("Could not start thread.\n");
ERROR(threads_free);
}
CPU_ZERO(&cpuset);
CPU_SET(cmds->ratios[i].cpu, &cpuset);
if (pthread_setaffinity_np(threads[i], sizeof(cpuset), &cpuset)) {
printf("Could not set affinity.\n");
ERROR(threads_free);
}
if (pthread_setschedparam(threads[i], SCHED_FIFO, ¶m)) {
printf("Could not go realtime.\n");
ERROR(threads_free);
}
}
//send_notification();
while (1) {
if (ctrlc) {
printf("CTRL+C received.\n");
w_lock(); /* begin writing */
finished = 1;
w_unlock(); /* stop writing */
break;
}
usleep(100000);
}
threads_join:
for (i=0; i < cmds->cpus; i++) {
if (pthread_join(threads[i], NULL)) {
printf("Threads could not be joined.\n");
ERROR(threads_free);
}
}
printf("Threads joined.\n");
threads_free:
free(threads);
barrier_free:
pthread_barrier_destroy(&barrier);
cmds_free:
//free(cmds);
finish:
printf("return = %d\n", return_value);
return return_value;
}
//! Select target and put event to window queue.
void w_receive_event(ui_event_t *e)
{
assert(e);
window_handle_t w = 0;
w_lock();
select_event_target(e);
window_handle_t later_lost = 0;
window_handle_t later_gain = 0;
if( e->focus == 0 )
{
//printf("unfocused event");
goto ret;
}
int later_x, later_y;
// For now use any mouse event to change focus
if(e->type == UI_EVENT_TYPE_MOUSE && focused_window != e->focus)
{
later_x = e->abs_x;
later_y = e->abs_y;
if(focused_window != 0)
later_lost = focused_window;
later_gain = e->focus;
focused_window = e->focus;
}
// Target
w = e->focus;
// Calc relative x, y
e->rel_x = e->abs_x - w->x;
e->rel_y = e->abs_y - w->y;
e->abs_z = w->z;
e->rel_z = 0;
// Not a best place - it can produce events too
if( e->type == UI_EVENT_TYPE_MOUSE )
{
ui_event_t ecopy = *e; // for any case
w_check_button( w, &ecopy );
}
if( w->events_count < MAX_WINDOW_EVENTS )
{
SHOW_FLOW(8, "e %p -> w %p", e, w);
#if DIRECT_DRIVE
if(w != 0 && w->inKernelEventProcess)
w->inKernelEventProcess(w, e);
#else
queue_enter(&(w->events), e, struct ui_event *, echain);
w->events_count++;
w->stall = 0;
#endif
}
void SeessionID::SetKillFlag(const std::string & sid, bool flag) {
WriteLock w_lock(myLock);
ptrsmap[sid].killflag = flag;
}
void SeessionID::Clear(const std::string & sid) {
WriteLock w_lock(myLock);
ptrsmap[sid].ptr_s.clear();
}
void SeessionID::Clear() {
WriteLock w_lock(myLock);
mmap.clear();
ptrsmap.clear();
}
void SeessionID::WriteHostInfo(const std::string& sid,
const std::string& hostname) {
WriteLock w_lock(myLock);
ptrsmap[sid].ptr_s.push_back(hostname);
}
