C++ print_event函数代码示例

// Called with the queue locked and with at least one element
CompileTask* AdvancedThresholdPolicy::select_task(CompileQueue* compile_queue) {
#if INCLUDE_JVMCI
  CompileTask *max_non_jvmci_task = NULL;
#endif
  CompileTask *max_task = NULL;
  Method* max_method = NULL;
  jlong t = os::javaTimeMillis();
  // Iterate through the queue and find a method with a maximum rate.
  for (CompileTask* task = compile_queue->first(); task != NULL;) {
    CompileTask* next_task = task->next();
    Method* method = task->method();
    update_rate(t, method);
    if (max_task == NULL) {
      max_task = task;
      max_method = method;
    } else {
      // If a method has been stale for some time, remove it from the queue.
      if (is_stale(t, TieredCompileTaskTimeout, method) && !is_old(method)) {
        if (PrintTieredEvents) {
          print_event(REMOVE_FROM_QUEUE, method, method, task->osr_bci(), (CompLevel)task->comp_level());
        }
        task->log_task_dequeued("stale");
        compile_queue->remove_and_mark_stale(task);
        method->clear_queued_for_compilation();
        task = next_task;
        continue;
      }

      // Select a method with a higher rate
      if (compare_methods(method, max_method)) {
        max_task = task;
        max_method = method;
      }
    }
    task = next_task;
  }

#if INCLUDE_JVMCI
  if (UseJVMCICompiler) {
    if (max_non_jvmci_task != NULL) {
      max_task = max_non_jvmci_task;
      max_method = max_task->method();
    }
  }
#endif

  if (max_task->comp_level() == CompLevel_full_profile && TieredStopAtLevel > CompLevel_full_profile
      && is_method_profiled(max_method)) {
    max_task->set_comp_level(CompLevel_limited_profile);
    if (PrintTieredEvents) {
      print_event(UPDATE_IN_QUEUE, max_method, max_method, max_task->osr_bci(), (CompLevel)max_task->comp_level());
    }
  }

  return max_task;
}

void set_event(uint8_t event_number)
{
	uint8_t which_pin = events[event_number].pin;
	
	actual_events[which_pin] = event_number;
	
	switch(which_pin)
	{
		case EXP0_PC2:
		case EXP1_PD4:
		case EXP2_PD7:
		case EXP3_PB0:
		set_pin(which_pin, events[event_number].pin_state);
		break;
		
		case PWM0_PD6:
		case PWM1_PD5:
		// not implemented yet case PWM2_PB1:
		// not implemented yet case PWM3_PD3:
		run_pwm(which_pin, &events[event_number]);
		break;
		
		default:break;
	}
	
	int32_t time = current_time();
	
	// event_time
	char formatted_date[30];
	timeToString(time, formatted_date);
	send_string(formatted_date);
	send_string(" ");
	
	print_event(event_number);
}

event_response_t mm_callback(vmi_instance_t vmi, vmi_event_t *event) {

    vmi_get_vcpureg(vmi, &cr3, CR3, 0);
    vmi_pid_t current_pid = vmi_dtb_to_pid(vmi, cr3);

    reg_t rip_test;
    vmi_get_vcpureg(vmi, &rip_test, RIP, 0);

    printf("Memevent: {\n\tPID %u. RIP 0x%lx:\n", current_pid, rip_test);

    print_event(event);

    if( current_pid == pid && event->mem_event.gla == rip) {
        printf("\tCought the original RIP executing again!");
        vmi_clear_event(vmi, event, NULL);
        interrupted = 1;
    } else {
        printf("\tEvent on same page, but not the same RIP");
        vmi_clear_event(vmi, event, NULL);

        /* These two calls are equivalent */
        //vmi_step_event(vmi, event, event->vcpu_id, 1, NULL);
        vmi_step_event(vmi, event, event->vcpu_id, 1, step_callback);
    }

    printf("\n}\n");
    return 0;
}

static void* get_event(void *unused)
{
	SaHpiEventT	event;
	SaErrorT	rv;        
	
	
	rv = saHpiSubscribe(sessionid, SAHPI_FALSE);
	if (rv != SA_OK) {
		printf("OpenHPI>Fail to Subscribe event\n");
		return (void *)0;
	}	
		
	for(;;){
		memset(&event, 0xF, sizeof(event));

		rv = saHpiEventGet(sessionid, SAHPI_TIMEOUT_BLOCK, &event, NULL, NULL);		
		if (rv != SA_OK ) {
			goto out;
		}
		
		if ( prt_flag == 1 ) 
			print_event(sessionid,&event);
	} /*the loop for retrieving event*/

out:
	printf( "Unsubscribe\n");
	rv = saHpiUnsubscribe( sessionid );

	return (void *)1;
}

/*
 * print out the whole event LIST
 */
void print_el()
{
	struct el *el;
	struct es *es_hd;
	struct es *es;

	assert (g_el->next);

	printf("\n\n");
	printf("[es] >>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<\n");
	printf("[es] >>>>>>>>>> Dumping all event sets  <<<<<<<<<<<<<\n");
	printf("[es] >>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<\n");

	for (el = g_el->next ; el != g_el ; el = el->next) {

		assert(el);
		es_hd = el->es_head;
		assert (es_hd);
	
		printf("\n[es] ***** Dumping next event set *****\n");

		for (es=es_hd->next ; es!=es_hd ; es=es->next)
			print_event(es);
	}     
}

//callback function
void mm_callback(vmi_instance_t vmi, vmi_event_t *event) {

    print_event(event);
    vmi_get_vcpureg(vmi,&rax,RAX,0);
    vmi_get_vcpureg(vmi,&rbx,RBX,0);
    vmi_get_vcpureg(vmi,&rcx,RCX,0);
    vmi_get_vcpureg(vmi,&rdx,RDX,0);
    vmi_get_vcpureg(vmi,&rsi,RSI,0);
    vmi_get_vcpureg(vmi,&rdi,RDI,0);
    printf("HYPERCALL is: %s\n RAX value is: %lx\n RBX value is: %lx\n RCX value is: %lx\n RDX value is: %lx\n RSI value is: %lx\n RDI value is: %lx\n",
	event->mem_event.hypercall,rax,rbx,rcx,rdx,rsi,rdi);

    if(event->mem_event.gla == event->mem_event.gla2) {
        printf("\tCought the original hypercall executing again!");
        vmi_clear_event(vmi, event);
        interrupted = 1;
    } else {
        printf("\tEvent on same page, but not the hypercall: %s",event->mem_event.hypercall);
        vmi_clear_event(vmi, event);

        /* These two calls are equivalent */
        //vmi_step_event(vmi, event, event->vcpu_id, 1, NULL);
        vmi_step_event(vmi, event, event->vcpu_id, 1, NULL);
    }

    printf("\n}\n");
}

static void
print_variable(Variable *var)
{
    GList *itr;

    printf("= Variable: %s =\n", var->name);

    printf("struct sml_object Variable: %p\n", var->sml_var);
    printf("Range %f - %f\n", var->min, var->max);
    printf("Current value: %f\n", var->cur_value);
    printf("Guess value: %f\n", var->guess_value);
    printf("Last event: %p\n", var->last_event);

    printf("Terms:\n");
    for (itr = var->terms; itr; itr = itr->next) {
        print_term(itr->data);
    }

    printf("Events:\n");
    for (itr = var->events; itr; itr = itr->next)
        print_event(itr->data);

    printf("Status Events:\n");
    for (itr = var->status_events; itr; itr = itr->next)
        print_status_event(itr->data);

    printf("====================\n");
}

// Check if the method can be compiled, change level if necessary
void SimpleThresholdPolicy::compile(methodHandle mh, int bci, CompLevel level, JavaThread* thread) {
  assert(level <= TieredStopAtLevel, "Invalid compilation level");
  if (level == CompLevel_none) {
    return;
  }
  // Check if the method can be compiled. If it cannot be compiled with C1, continue profiling
  // in the interpreter and then compile with C2 (the transition function will request that,
  // see common() ). If the method cannot be compiled with C2 but still can with C1, compile it with
  // pure C1.
  if (!can_be_compiled(mh, level)) {
    if (level == CompLevel_full_optimization && can_be_compiled(mh, CompLevel_simple)) {
        compile(mh, bci, CompLevel_simple, thread);
    }
    return;
  }
  if (bci != InvocationEntryBci && mh->is_not_osr_compilable(level)) {
    return;
  }
  if (!CompileBroker::compilation_is_in_queue(mh)) {
    if (PrintTieredEvents) {
      print_event(COMPILE, mh, mh, bci, level);
    }
    submit_compile(mh, bci, level, thread);
  }
}

static leaf_error_t leaf_run()
{
	xcb_generic_event_t *event = NULL;
	int etype;
	leaf_error_t status = ERR_NONE;

	/* Start main loop */
	gconf.running = true;
	do {
		event = xcb_poll_for_event(gconf.conn);
		if (!event) {
            if (xcb_connection_has_error(gconf.conn))
	            return ERR_CONN;
			continue;
		}
		etype = XCB_EVENT_RESPONSE_TYPE(event);

		/* Only for debug prupose */
		print_event(etype);

		/* Execute specific event handler */
		if (geventhandlers[etype])
			if (geventhandlers[etype](event) != EVENT_ERR_NONE)
				status = ERR_EVENT;
		free(event);
	} while (gconf.running && status == ERR_NONE);

	return status;
}

/**
 * \brief Timer handler for supporting peer search
 *
 * \param parameter pass parameters to timer handler
 */
static void app_peer_conf_tmr_handler_cb( void *parameter)
{
	trx_id_t trx = (trx_id_t)parameter;
	print_event(trx, PRINT_PEER_SEARCH_FAILED);
	/* No PEER CONF so change to WAIT_FOR_EVENT state*/
	set_main_state(trx, WAIT_FOR_EVENT, 0);
}

void handle_event(int epfd, struct epoll_event ev) {
	struct fdinfo *fdinfo = ev.data.ptr;

	switch (fdinfo->type) {
	case LSOCK:
		accept_one(epfd, fdinfo->fd);
		break;
	case CLIENT:
		print_event(fdinfo->fd, ev);
		if (ev.events & EPOLLHUP) {
			kill_cli(epfd, fdinfo);
			return;
		}

		if (ev.events & EPOLLIN) {
			handle_cli(fdinfo);
		}

		if (ev.events & EPOLLRDHUP)  {
			handle_cli(fdinfo);
			kill_cli(epfd, fdinfo);
			return;
		}

		break;
	}
}

static void
check_event(FAMConnection * fc)
{
    int ret;
    FAMEvent fe;

    ret = FAMPending(fc);
    if (ret < 0) {
        fprintf(stderr, "FAMPending() failed\n");
        exit(1);
    }
    while (ret > 0) {
        ret = FAMNextEvent(fc, &fe);
        if (ret < 0) {
            fprintf(stderr, "FAMNextEvent() failed\n");
            exit(1);
        }
        print_event(&fe);
        ret = FAMPending(fc);
        if (ret < 0) {
            fprintf(stderr, "FAMPending() failed\n");
            exit(1);
        }
    }
}

void print_event_to_log(Display* dpy, XEvent* ev)
{
#ifdef DEBUG_PRINTOUTS
  if ((ev->type != PropertyNotify) && (ev->type != ConfigureNotify)) {
    print_event(g_out_stream, ev, dpy);
  }
#endif
}

/* Print all events */
void print_events(void)
{
	list_node_t *it;
	for (it = events->head; it; it = it->next) {
		struct event *event = it->data;
		if (event)
			print_event(event);
	}
}

/**
 * \brief Timer handler for supporting peer search
 *
 * \param parameter pass parameters to timer handler
 */
static void app_peer_conf_tmr_handler_cb(void *parameter)
{
	print_event(PRINT_PEER_SEARCH_FAILED);
	/* No PEER CONF so change to WAIT_FOR_EVENT state*/
	set_main_state(WAIT_FOR_EVENT, 0);

	/* keep compiler happy */
	parameter = parameter;
}