static int
check_values(Heap *h,int idx,int depth)
{
HeapElement *he_l = NULL;
HeapElement *he_r = NULL;
HeapElement *he_p = NULL;
HeapInternCmp cmp_func;
if (idx < 0 || idx >= HSIZE(h))
return 0;
if (h->hpMode == HEAP_MINIMIZE)
cmp_func = heap_larger;
else
cmp_func = heap_smaller;
he_p = HARRAY(h,idx);
if (HLEFT(idx) >= HSIZE(h)) /* No left child */
return 0;
if (HRIGHT(idx) < HSIZE(h)) /* Has right child */
he_r = HARRAY(h,HRIGHT(idx));
he_l = HARRAY(h,HLEFT(idx));
if ( cmp_func(h,he_p,he_l))
{
printf("*** Heap violates parent-lchild property.\n");
printf("*** Left child (%d) is %s than parent (%d)\n",
HLEFT(idx),
h->hpMode == HEAP_MINIMIZE ? "smaller" : "larger",
idx);
printf("*** Depth %d\n",depth);
printf("%.8f - %.8f = %.8f\n",Key2Double(he_l),Key2Double(he_p),
Key2Double(he_l) - Key2Double(he_p));
return -1;
}
if (he_r && cmp_func(h,he_p,he_r))
{
printf("*** Heap violates parent-rchild property.\n");
printf("*** Right child (%d) is %s than parent (%d)\n",
HRIGHT(idx),h->hpMode == HEAP_MINIMIZE ? "smaller" : "larger",
idx);
printf("*** Depth %d\n",depth);
printf("%.8f - %.8f = %.8f\n",Key2Double(he_r),Key2Double(he_p),
Key2Double(he_r) - Key2Double(he_p));
return -1;
}
if (check_values(h,HLEFT(idx),depth+1))
return -1;
if (he_r)
return check_values(h,HRIGHT(idx),depth+1);
return 0;
}
void ShortcutDialog::on_validate()
{
int ok = check_values() ;
if (ok==1) {
chosen_path = path_entry.get_text() ;
chosen_display = display_entry.get_text() ;
response(Gtk::RESPONSE_OK) ;
}
else if (ok<0) {
Glib::ustring txt ;
if (ok==-1)
txt = _("Please enter a shortcut name ") ;
else if (ok==-2)
txt = _("Please choose a target") ;
else if (ok==-3)
txt = _("This target is already used by a shortcut") ;
else if (ok==-4)
txt = _("This target does not exist") ;
else if (ok==-5)
txt = _("This name is too long or contains invalid symbol, please choose another") ;
else if (ok==-6)
txt = _("Please change directory permissions (enable read and execute) or change directory") ;
Explorer_dialog::msg_dialog_warning(txt, this, true) ;
}
}
/**
* facq_net_send:
* @skt: A connected #GSocket object.
* @buf: A pointer to the memory area that contains the data that you want to
* send.
* @size: The size of the memory area pointed by @buf, in bytes.
* @retry: The number of retries or 0 for infinite retries.
* @err: A #GError, it will be set in case of error if not %NULL.
*
* Tries to send the number of bytes, @size, in the memory area pointed by @buf,
* using at most @retry retries.
*
* returns: The number of bytes sent if successful, -1 in case of error,
* -2 in case of timeout, -3 if wrong parameters are passed to the function.
*/
gssize facq_net_send(GSocket *skt,gchar *buf,gsize size,guint retry,GError **err)
{
guint retries = 0;
GError *local_err = NULL;
gsize to_send = 0, remaining = 0;
gssize ret = 0, total = 0;
if(!check_values(skt,buf,size)) {
if(err != NULL)
g_set_error_literal(err,G_IO_ERROR,
G_IO_ERROR_FAILED,"Can't send any data");
return -3;
}
if(retry == 0)
retry = G_MAXUINT;
to_send = 0;
remaining = size;
/* Try to send all the data in one call, retrying at most retry times */
for(retries = 0; retries < retry; retries++) {
ret = g_socket_send(skt,&buf[to_send],remaining,NULL,&local_err);
if(ret <= 0) {
if(local_err) {
facq_log_write_v(FACQ_LOG_MSG_TYPE_ERROR,
"%s",local_err->message);
if(err != NULL)
g_propagate_error(err,local_err);
return -1;
}
else {
if(err != NULL)
g_set_error_literal(err,G_IO_ERROR,
G_IO_ERROR_FAILED,"Error sending data");
return -1;
}
}
else {
total += ret;
remaining = size - total;
to_send += ret;
if(total == size)
break;
#if ENABLE_DEBUG
facq_log_write_v(FACQ_LOG_MSG_TYPE_DEBUG,"%s",
"Retrying to send all the data");
#endif
}
}
if(total != size) {
if(err != NULL)
g_set_error_literal(err,G_IO_ERROR,
G_IO_ERROR_TIMED_OUT,"Operation timed out");
return -2;
}
return total;
}
int insert_signals( T& signal,
char * signal_name,
char * wu_name,
sqlint8_t sah_result_id,
std::ifstream& result_file,
receiver_config& receiver_cfg,
int appid,
int max_signals_allowed,
list<long>& qpixlist) {
int signal_count=0, signal_inserted_count=0, retval=0, qpix;
sqlint8_t signal_id=0;
result_file.clear();
result_file.seekg(0);
while (!result_file.eof()) {
result_file >> signal;
if (!result_file.eof()) {
signal_count++;
if (max_signals_allowed == 0 || signal_count <= max_signals_allowed) {
if (!(signal.rfi_found = check_values(signal, sah_result_id, wu_name))) {
// preprocess only if we have good values
retval = pre_process(signal, receiver_cfg);
qpixlist.push_back(npix2qpix((long long)signal.q_pix));
}
signal.result_id = sah_result_id;
if (appid == 2) signal.reserved = 1; // temporary for enhanced rollout
signal_id = signal.insert();
if (signal_id) {
log_messages.printf(SCHED_MSG_LOG::MSG_DEBUG,
"[%s] Inserted %s %"INT8_FMT" for sah result %"INT8_FMT"\n",
wu_name, signal_name, INT8_PRINT_CAST(signal_id), INT8_PRINT_CAST(sah_result_id)
);
signal_inserted_count++;
} else {
log_messages.printf(SCHED_MSG_LOG::MSG_CRITICAL,
"[%s] Could not insert %s for sah result %"INT8_FMT". SQLCODE is %d. q_pix is %"INT8_FMT" ra is %lf decl is %lf .\n",
wu_name, signal_name, sah_result_id, sql_last_error_code(), signal.q_pix, signal.ra, signal.decl
);
#if 0
log_messages.printf(SCHED_MSG_LOG::MSG_CRITICAL,
"[%s] Could not insert %s for sah result %ld. SQLCODE is %d. SQLMSG is %s q_pix is %"INT8_FMT".\n",
wu_name, signal_name, sah_result_id, sql_last_error_code(), sql_error_message(), signal.q_pix
);
#endif
return -1;
}
}
}
}
log_messages.printf(SCHED_MSG_LOG::MSG_NORMAL,
"[%s] Inserted %d out of %d %s(s) for sah result %"INT8_FMT" \n",
wu_name, signal_inserted_count, signal_count, signal_name, INT8_PRINT_CAST(sah_result_id)
);
}
static void test_slice_hash_table() {
const test_entry test_entries[] = {
{"key_0", "value_0"}, {"key_1", "value_1"}, {"key_2", "value_2"},
{"key_3", "value_3"}, {"key_4", "value_4"}, {"key_5", "value_5"},
{"key_6", "value_6"}, {"key_7", "value_7"}, {"key_8", "value_8"},
{"key_9", "value_9"}, {"key_10", "value_10"}, {"key_11", "value_11"},
{"key_12", "value_12"}, {"key_13", "value_13"}, {"key_14", "value_14"},
{"key_15", "value_15"}, {"key_16", "value_16"}, {"key_17", "value_17"},
{"key_18", "value_18"}, {"key_19", "value_19"}, {"key_20", "value_20"},
{"key_21", "value_21"}, {"key_22", "value_22"}, {"key_23", "value_23"},
{"key_24", "value_24"}, {"key_25", "value_25"}, {"key_26", "value_26"},
{"key_27", "value_27"}, {"key_28", "value_28"}, {"key_29", "value_29"},
{"key_30", "value_30"}, {"key_31", "value_31"}, {"key_32", "value_32"},
{"key_33", "value_33"}, {"key_34", "value_34"}, {"key_35", "value_35"},
{"key_36", "value_36"}, {"key_37", "value_37"}, {"key_38", "value_38"},
{"key_39", "value_39"}, {"key_40", "value_40"}, {"key_41", "value_41"},
{"key_42", "value_42"}, {"key_43", "value_43"}, {"key_44", "value_44"},
{"key_45", "value_45"}, {"key_46", "value_46"}, {"key_47", "value_47"},
{"key_48", "value_48"}, {"key_49", "value_49"}, {"key_50", "value_50"},
{"key_51", "value_51"}, {"key_52", "value_52"}, {"key_53", "value_53"},
{"key_54", "value_54"}, {"key_55", "value_55"}, {"key_56", "value_56"},
{"key_57", "value_57"}, {"key_58", "value_58"}, {"key_59", "value_59"},
{"key_60", "value_60"}, {"key_61", "value_61"}, {"key_62", "value_62"},
{"key_63", "value_63"}, {"key_64", "value_64"}, {"key_65", "value_65"},
{"key_66", "value_66"}, {"key_67", "value_67"}, {"key_68", "value_68"},
{"key_69", "value_69"}, {"key_70", "value_70"}, {"key_71", "value_71"},
{"key_72", "value_72"}, {"key_73", "value_73"}, {"key_74", "value_74"},
{"key_75", "value_75"}, {"key_76", "value_76"}, {"key_77", "value_77"},
{"key_78", "value_78"}, {"key_79", "value_79"}, {"key_80", "value_80"},
{"key_81", "value_81"}, {"key_82", "value_82"}, {"key_83", "value_83"},
{"key_84", "value_84"}, {"key_85", "value_85"}, {"key_86", "value_86"},
{"key_87", "value_87"}, {"key_88", "value_88"}, {"key_89", "value_89"},
{"key_90", "value_90"}, {"key_91", "value_91"}, {"key_92", "value_92"},
{"key_93", "value_93"}, {"key_94", "value_94"}, {"key_95", "value_95"},
{"key_96", "value_96"}, {"key_97", "value_97"}, {"key_98", "value_98"},
{"key_99", "value_99"},
};
const size_t num_entries = GPR_ARRAY_SIZE(test_entries);
// Construct table.
grpc_slice_hash_table_entry* entries =
gpr_zalloc(sizeof(*entries) * num_entries);
populate_entries(test_entries, num_entries, entries);
grpc_slice_hash_table* table =
grpc_slice_hash_table_create(num_entries, entries, destroy_string);
gpr_free(entries);
// Check contents of table.
check_values(test_entries, num_entries, table);
check_non_existent_value("XX", table);
// Clean up.
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
grpc_slice_hash_table_unref(&exec_ctx, table);
grpc_exec_ctx_finish(&exec_ctx);
}
bool PrismaticModel::guessParameters() {
if(model.track.pose.size() < 2)
return false;
size_t i,j;
do{
i = rand() % getSamples();
j = rand() % getSamples();
} while (i==j);
tf::Transform pose1 = poseToTransform(model.track.pose[i]);
tf::Transform pose2 = poseToTransform(model.track.pose[j]);
rigid_position = pose1.getOrigin();
rigid_orientation = pose1.getRotation();
prismatic_dir = pose2.getOrigin() - pose1.getOrigin();
prismatic_dir.normalize();
if(!check_values(rigid_position)) return false;
if(!check_values(rigid_orientation)) return false;
if(!check_values(prismatic_dir)) return false;
return true;
}
/* This function assigns values to the face cards and others based on user input
card_name: the name of the card truncated to 2 characters
val: the value of the card to be set in this function
*/
void assign_values(char card_name[], int *val)
{
switch(card_name[0]) {
case 'K':
case 'Q':
case 'J':
*val = 10;
break;
case 'A':
*val = 11;
break;
default:
*val = atoi(card_name);
if ((*val < 2) || (*val > 10)) {
puts("I don't understand that value!");
}
}
check_values(&value, &count);
}
int main( int argc, const char *argv[])
{
int h1,h2,m1,m2, difh=0, difm=0 ;
printf("digite as horas do horario de inicio(valor entre 0-23)\n");
scanf ( "%d", &h1 );
printf ( "digite os minutos do horario de inicio (valor entre 0-59)\n" );
scanf ( "%d", &m1 );
printf ( "digite as horas do horario de termino (valor entre 0-23)\n");
scanf ( "%d", &h2 );
printf ( "digite os minutos do horario de termino (valor entre 0-59)\n" );
scanf ( "%d", &m2 );
if(check_values(h1,h2,m1,m2))
{
difm = dif_min(m1,m2);
difh = dif_hour(h1,h2,m1,m2);
printf("A duração do jogo é de %d horas e %d minutos.\n",difh,difm);
}
else
{
printf ( "Dados Inválidos \n" );
}
return 0;
}
static GList * cover_jamendo_parse (cb_object *capo)
{
// A nice parser with zero memory overhead..
GList * result_list = NULL;
gchar * line = capo->cache->data;
while (continue_search (g_list_length (result_list),capo->s) )
{
char * line_end;
if ( (line_end = strchr (line,'\n') ) != NULL)
{
*line_end = 0;
char * line_split[3] = {0,0,0};
do_line_split (line_split,line);
if (check_values (capo->s,line_split[2],line_split[1]) )
{
char * url = g_strdup_printf (RESULT_URL,line_split[0],get_cover_size (capo->s) );
GlyrMemCache * result = DL_init();
result->data = url;
result->size = strlen (url);
result_list = g_list_prepend (result_list,result);
}
line = ++line_end;
}
else
{
break;
}
}
return result_list;
}
void runTest(int prec1, int prec2, int loc1, int loc2, int matrix,
int extended, double time_average)
{
int num_baselines, status = 0, type;
oskar_Mem *vis1, *vis2;
oskar_Timer *timer1, *timer2;
double time1, time2, frequency = 100e6;
// Create the timers.
timer1 = oskar_timer_create(loc1 == OSKAR_GPU ?
OSKAR_TIMER_CUDA : OSKAR_TIMER_NATIVE);
timer2 = oskar_timer_create(loc2 == OSKAR_GPU ?
OSKAR_TIMER_CUDA : OSKAR_TIMER_NATIVE);
// Run first part.
createTestData(prec1, loc1, matrix);
num_baselines = oskar_telescope_num_baselines(tel);
type = prec1 | OSKAR_COMPLEX;
if (matrix) type |= OSKAR_MATRIX;
vis1 = oskar_mem_create(type, loc1, num_baselines, &status);
oskar_mem_clear_contents(vis1, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
oskar_sky_set_use_extended(sky, extended);
oskar_telescope_set_channel_bandwidth(tel, bandwidth);
oskar_telescope_set_time_average(tel, time_average);
oskar_timer_start(timer1);
oskar_cross_correlate(vis1, oskar_sky_num_sources(sky), jones, sky,
tel, u_, v_, w_, 1.0, frequency, &status);
time1 = oskar_timer_elapsed(timer1);
destroyTestData();
ASSERT_EQ(0, status) << oskar_get_error_string(status);
// Run second part.
createTestData(prec2, loc2, matrix);
num_baselines = oskar_telescope_num_baselines(tel);
type = prec2 | OSKAR_COMPLEX;
if (matrix) type |= OSKAR_MATRIX;
vis2 = oskar_mem_create(type, loc2, num_baselines, &status);
oskar_mem_clear_contents(vis2, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
oskar_sky_set_use_extended(sky, extended);
oskar_telescope_set_channel_bandwidth(tel, bandwidth);
oskar_telescope_set_time_average(tel, time_average);
oskar_timer_start(timer2);
oskar_cross_correlate(vis2, oskar_sky_num_sources(sky), jones, sky,
tel, u_, v_, w_, 1.0, frequency, &status);
time2 = oskar_timer_elapsed(timer2);
destroyTestData();
ASSERT_EQ(0, status) << oskar_get_error_string(status);
// Destroy the timers.
oskar_timer_free(timer1);
oskar_timer_free(timer2);
// Compare results.
check_values(vis1, vis2);
// Free memory.
oskar_mem_free(vis1, &status);
oskar_mem_free(vis2, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
// Record properties for test.
RecordProperty("SourceType", extended ? "Gaussian" : "Point");
RecordProperty("JonesType", matrix ? "Matrix" : "Scalar");
RecordProperty("TimeSmearing", time_average == 0.0 ? "off" : "on");
RecordProperty("Prec1", prec1 == OSKAR_SINGLE ? "Single" : "Double");
RecordProperty("Loc1", loc1 == OSKAR_CPU ? "CPU" : "GPU");
RecordProperty("Time1_ms", int(time1 * 1000));
RecordProperty("Prec2", prec2 == OSKAR_SINGLE ? "Single" : "Double");
RecordProperty("Loc2", loc2 == OSKAR_CPU ? "CPU" : "GPU");
RecordProperty("Time2_ms", int(time2 * 1000));
#ifdef ALLOW_PRINTING
// Print times.
printf(" > %s. %s sources. Time smearing %s.\n",
matrix ? "Matrix" : "Scalar",
extended ? "Gaussian" : "Point",
time_average == 0.0 ? "off" : "on");
printf(" %s precision %s: %.2f ms, %s precision %s: %.2f ms\n",
prec1 == OSKAR_SINGLE ? "Single" : "Double",
loc1 == OSKAR_CPU ? "CPU" : "GPU",
time1 * 1000.0,
prec2 == OSKAR_SINGLE ? "Single" : "Double",
loc2 == OSKAR_CPU ? "CPU" : "GPU",
time2 * 1000.0);
#endif
}
int main(void)
{
/* ######################### Variables ######################### */
/* Variables for modbus */
modbus_t *ctx;
int pollingInterval;
uint16_t valueArray[2];
float floatValue;
int no_register;
uint8_t desiredBit;
GenDataType_t dataType;
MoBuRegType_t registerType;
/* Variables for mosquitto */
struct mosquitto *mosq;
char topic[BUFFER_SIZE];
char text[50];
/* Variables for time */
struct timespec last_read_time;
struct timespec now;
/* ######################### Initialize variables ######################### */
sprintf(topic, "/test");
/* Read values from configfile */
if(getStringFromFile_n(CONFIG_FILE_PATH, "mosquitto_topic", topic, BUFFER_SIZE) == -1) {
log_entry(APP_NAME, "Error reading topic");
printf("Error reading topic..\n");
/* wait for new config */
wait_for_new_config();
return EXIT_FAILURE;
}
pollingInterval = getIntFromFile(CONFIG_FILE_PATH, "modbus_polling_Interval");
no_register = getIntFromFile(CONFIG_FILE_PATH, "modbus_register");
dataType = getIntFromFile(CONFIG_FILE_PATH, "modbus_data_type");
registerType = getIntFromFile(CONFIG_FILE_PATH, "modbus_register_type");
desiredBit = getIntFromFile(CONFIG_FILE_PATH, "modbus_desired_bit");
/* Check values of variables */
if(check_values(no_register, pollingInterval) == ERROR) {
log_entry(APP_NAME, "Error: Invalid values");
/* wait for new config */
wait_for_new_config();
return EXIT_FAILURE;
}
/* ######################### Initialize communication ######################### */
/* Initialize Mosquitto */
printf(SPLIT_LINE);
mosq = mosquitto_initialize(CONFIG_FILE_PATH);
if(mosq == NULL) {
log_entry(APP_NAME, "Error: Could not initialize mqtt connection");
/* wait for new config */
wait_for_new_config();
return EXIT_FAILURE;
}
/* Initialize Modbus */
printf(SPLIT_LINE);
ctx = modbus_init(CONFIG_FILE_PATH);
if(ctx == NULL) {
log_entry(APP_NAME, "Error: Could not initialize modbus connection");
/* wait for new config */
wait_for_new_config();
return EXIT_FAILURE;
}
/* Initialize time */
clock_gettime(CLOCK_MONOTONIC, &last_read_time);
/* ######################### Start application ######################### */
printf(SPLIT_LINE);
log_entry(APP_NAME, "Start reading values..");
printf("\nStart reading values..\n\n");
/* Endless Loop */
while(1)
{
clock_gettime(CLOCK_MONOTONIC, &now);
/* Check if polling time is over (multiply with 1000 to calculate seconds) */
if(diff(&last_read_time, &now) >= pollingInterval * 1000) {
/* Read values from modbus */
if(read_modbus(ctx, 0, no_register, dataType, registerType, desiredBit, valueArray) == ERROR) {
/* Set last read time */
clock_gettime(CLOCK_MONOTONIC, &last_read_time);
continue;
}
switch(dataType)
{
case bitCoil:
case sint16:
case sint32:
case uint16:
case uint32:
floatValue = modbus_get_float(valueArray);
sprintf(text, "%.0f", floatValue);
break;
case float32:
floatValue = modbus_get_float(valueArray);
sprintf(text, "%.2f", floatValue);
break;
}
/* Message for user */
printf("Value: %s\n", text);
/* Publish value */
if(mosquitto_pub(mosq, topic, strlen(text), text) == SUCCESS) {
log_entry(APP_NAME, "Published value successfully");
printf("Published value successfully.\n\n");
} else {
log_entry(APP_NAME, "Error: Value could not be published.");
printf("Error: Value could not be published.\n");
}
/* Set last read time */
clock_gettime(CLOCK_MONOTONIC, &last_read_time);
}
/* taking care of processor and slow down the loop */
usleep(500);
}
/* We should never get here */
mosquitto_quit(mosq);
modbus_quit(ctx);
log_entry(APP_NAME, "Quit application");
return EXIT_SUCCESS;
}
void crf1dc_debug_context(FILE *fp)
{
int y1, y2, y3;
floatval_t norm = 0;
const int L = 3;
const int T = 3;
crf1d_context_t *ctx = crf1dc_new(CTXF_MARGINALS, L, T);
floatval_t *trans = NULL, *state = NULL;
floatval_t scores[3][3][3];
int labels[3];
/* Initialize the state scores. */
state = EXP_STATE_SCORE(ctx, 0);
state[0] = .4; state[1] = .5; state[2] = .1;
state = EXP_STATE_SCORE(ctx, 1);
state[0] = .4; state[1] = .1; state[2] = .5;
state = EXP_STATE_SCORE(ctx, 2);
state[0] = .4; state[1] = .1; state[2] = .5;
/* Initialize the transition scores. */
trans = EXP_TRANS_SCORE(ctx, 0);
trans[0] = .3; trans[1] = .1; trans[2] = .4;
trans = EXP_TRANS_SCORE(ctx, 1);
trans[0] = .6; trans[1] = .2; trans[2] = .1;
trans = EXP_TRANS_SCORE(ctx, 2);
trans[0] = .5; trans[1] = .2; trans[2] = .1;
ctx->num_items = ctx->cap_items;
crf1dc_alpha_score(ctx);
crf1dc_beta_score(ctx);
/* Compute the score of every label sequence. */
for (y1 = 0;y1 < L;++y1) {
floatval_t s1 = EXP_STATE_SCORE(ctx, 0)[y1];
for (y2 = 0;y2 < L;++y2) {
floatval_t s2 = s1;
s2 *= EXP_TRANS_SCORE(ctx, y1)[y2];
s2 *= EXP_STATE_SCORE(ctx, 1)[y2];
for (y3 = 0;y3 < L;++y3) {
floatval_t s3 = s2;
s3 *= EXP_TRANS_SCORE(ctx, y2)[y3];
s3 *= EXP_STATE_SCORE(ctx, 2)[y3];
scores[y1][y2][y3] = s3;
}
}
}
/* Compute the partition factor. */
norm = 0.;
for (y1 = 0;y1 < L;++y1) {
for (y2 = 0;y2 < L;++y2) {
for (y3 = 0;y3 < L;++y3) {
norm += scores[y1][y2][y3];
}
}
}
/* Check the partition factor. */
fprintf(fp, "Check for the partition factor... ");
check_values(fp, exp(ctx->log_norm), norm);
/* Compute the sequence probabilities. */
for (y1 = 0;y1 < L;++y1) {
for (y2 = 0;y2 < L;++y2) {
for (y3 = 0;y3 < L;++y3) {
floatval_t logp;
labels[0] = y1;
labels[1] = y2;
labels[2] = y3;
logp = crf1dc_score(ctx, labels) - crf1dc_lognorm(ctx);
fprintf(fp, "Check for the sequence %d-%d-%d... ", y1, y2, y3);
check_values(fp, exp(logp), scores[y1][y2][y3] / norm);
}
}
}
/* Compute the marginal probability at t=0 */
for (y1 = 0;y1 < L;++y1) {
floatval_t a, b, c, s = 0.;
for (y2 = 0;y2 < L;++y2) {
for (y3 = 0;y3 < L;++y3) {
s += scores[y1][y2][y3];
}
}
a = ALPHA_SCORE(ctx, 0)[y1];
b = BETA_SCORE(ctx, 0)[y1];
c = 1. / ctx->scale_factor[0];
fprintf(fp, "Check for the marginal probability (0,%d)... ", y1);
check_values(fp, a * b * c, s / norm);
}
/* Compute the marginal probability at t=1 */
for (y2 = 0;y2 < L;++y2) {
floatval_t a, b, c, s = 0.;
for (y1 = 0;y1 < L;++y1) {
for (y3 = 0;y3 < L;++y3) {
s += scores[y1][y2][y3];
}
}
a = ALPHA_SCORE(ctx, 1)[y2];
b = BETA_SCORE(ctx, 1)[y2];
c = 1. / ctx->scale_factor[1];
fprintf(fp, "Check for the marginal probability (1,%d)... ", y2);
check_values(fp, a * b * c, s / norm);
}
/* Compute the marginal probability at t=2 */
for (y3 = 0;y3 < L;++y3) {
floatval_t a, b, c, s = 0.;
for (y1 = 0;y1 < L;++y1) {
for (y2 = 0;y2 < L;++y2) {
s += scores[y1][y2][y3];
}
}
a = ALPHA_SCORE(ctx, 2)[y3];
b = BETA_SCORE(ctx, 2)[y3];
c = 1. / ctx->scale_factor[2];
fprintf(fp, "Check for the marginal probability (2,%d)... ", y3);
check_values(fp, a * b * c, s / norm);
}
/* Compute the marginal probabilities of transitions. */
for (y1 = 0;y1 < L;++y1) {
for (y2 = 0;y2 < L;++y2) {
floatval_t a, b, s, t, p = 0.;
for (y3 = 0;y3 < L;++y3) {
p += scores[y1][y2][y3];
}
a = ALPHA_SCORE(ctx, 0)[y1];
b = BETA_SCORE(ctx, 1)[y2];
s = EXP_STATE_SCORE(ctx, 1)[y2];
t = EXP_TRANS_SCORE(ctx, y1)[y2];
fprintf(fp, "Check for the marginal probability (0,%d)-(1,%d)... ", y1, y2);
check_values(fp, a * t * s * b, p / norm);
}
}
for (y2 = 0;y2 < L;++y2) {
for (y3 = 0;y3 < L;++y3) {
floatval_t a, b, s, t, p = 0.;
for (y1 = 0;y1 < L;++y1) {
p += scores[y1][y2][y3];
}
a = ALPHA_SCORE(ctx, 1)[y2];
b = BETA_SCORE(ctx, 2)[y3];
s = EXP_STATE_SCORE(ctx, 2)[y3];
t = EXP_TRANS_SCORE(ctx, y2)[y3];
fprintf(fp, "Check for the marginal probability (1,%d)-(2,%d)... ", y2, y3);
check_values(fp, a * t * s * b, p / norm);
}
}
}
/*
* check_results --
* Check all the tables and verify the results.
*/
static int
check_results(TEST_OPTS *opts, uint64_t *foundp)
{
WT_CURSOR *maincur, *maincur2, *v0cur, *v1cur, *v2cur;
WT_SESSION *session;
uint64_t count, idxcount, nrecords;
uint32_t rndint;
int key, key_got, ret, v0, v1, v2;
char *big, *bigref;
testutil_check(create_big_string(&bigref));
nrecords = opts->nrecords;
testutil_check(wiredtiger_open(opts->home, NULL,
"create,log=(enabled)", &opts->conn));
testutil_check(
opts->conn->open_session(opts->conn, NULL, NULL, &session));
testutil_check(session->open_cursor(session, "table:subtest", NULL,
NULL, &maincur));
testutil_check(session->open_cursor(session, "table:subtest2", NULL,
NULL, &maincur2));
testutil_check(session->open_cursor(session, "index:subtest:v0", NULL,
NULL, &v0cur));
testutil_check(session->open_cursor(session, "index:subtest:v1", NULL,
NULL, &v1cur));
testutil_check(session->open_cursor(session, "index:subtest:v2", NULL,
NULL, &v2cur));
count = 0;
while ((ret = maincur->next(maincur)) == 0) {
testutil_check(maincur2->next(maincur2));
testutil_check(maincur2->get_key(maincur2, &key_got));
testutil_check(maincur2->get_value(maincur2, &rndint));
generate_key(count, &key);
generate_value(rndint, count, bigref, &v0, &v1, &v2, &big);
testutil_assert(key == key_got);
/* Check the key/values in main table. */
testutil_check(maincur->get_key(maincur, &key_got));
testutil_assert(key == key_got);
check_values(maincur, v0, v1, v2, big);
/* Check the values in the indices. */
v0cur->set_key(v0cur, v0);
testutil_check(v0cur->search(v0cur));
check_values(v0cur, v0, v1, v2, big);
v1cur->set_key(v1cur, v1);
testutil_check(v1cur->search(v1cur));
check_values(v1cur, v0, v1, v2, big);
v2cur->set_key(v2cur, v2);
testutil_check(v2cur->search(v2cur));
check_values(v2cur, v0, v1, v2, big);
count++;
if (count % VERBOSE_PRINT == 0 && opts->verbose)
printf("checked %" PRIu64 "/%" PRIu64 "\n", count,
nrecords);
}
if (count % VERBOSE_PRINT != 0 && opts->verbose)
printf("checked %" PRIu64 "/%" PRIu64 "\n", count, nrecords);
/*
* Always expect at least one entry, as populate does a
* checkpoint after the first insert.
*/
testutil_assert(count > 0);
testutil_assert(ret == WT_NOTFOUND);
testutil_assert(maincur2->next(maincur2) == WT_NOTFOUND);
cursor_count_items(v0cur, &idxcount);
testutil_assert(count == idxcount);
cursor_count_items(v1cur, &idxcount);
testutil_assert(count == idxcount);
cursor_count_items(v2cur, &idxcount);
testutil_assert(count == idxcount);
testutil_check(opts->conn->close(opts->conn, NULL));
opts->conn = NULL;
free(bigref);
*foundp = count;
return (0);
}
int main(int argc, char **argv)
{
PAPI_event_info_t info;
int i, j, retval;
int iters = NUM_FLOPS;
double x = 1.1, y;
long long t1, t2;
long long values[MAXEVENTS], refvalues[MAXEVENTS];
int sleep_time = SLEEPTIME;
double valsqsum[MAXEVENTS];
double valsum[MAXEVENTS];
int nevents = MAXEVENTS;
int eventset = PAPI_NULL;
int events[MAXEVENTS];
events[0] = PAPI_FP_INS;
events[1] = PAPI_TOT_INS;
events[2] = PAPI_INT_INS;
events[3] = PAPI_TOT_CYC;
events[4] = PAPI_STL_CCY;
events[5] = PAPI_BR_INS;
events[6] = PAPI_SR_INS;
events[7] = PAPI_LD_INS;
events[8] = PAPI_TOT_IIS;
events[9] = PAPI_FAD_INS;
events[10] = PAPI_BR_TKN;
events[11] = PAPI_BR_MSP;
events[12] = PAPI_L1_ICA;
events[13] = PAPI_L1_DCA;
for (i = 0; i < MAXEVENTS; i++) {
values[i] = 0;
valsqsum[i] = 0;
valsum[i] = 0;
}
if (argc > 1) {
if (!strcmp(argv[1], "TESTS_QUIET"))
tests_quiet(argc, argv);
else {
sleep_time = atoi(argv[1]);
if (sleep_time <= 0)
sleep_time = SLEEPTIME;
}
}
if (!TESTS_QUIET) {
printf("\nAccuracy check of multiplexing routines.\n");
printf("Comparing a multiplex measurement with separate measurements.\n\n");
}
if ((retval = PAPI_library_init(PAPI_VER_CURRENT)) != PAPI_VER_CURRENT)
test_fail(__FILE__, __LINE__, "PAPI_library_init", retval);
decide_which_events(events, &nevents);
init_multiplex();
/* Find a reasonable number of iterations (each
* event active 20 times) during the measurement
*/
t2 = 10000 * 20 * nevents; /* Target: 10000 usec/multiplex, 20 repeats */
if (t2 > 30e6)
test_skip(__FILE__, __LINE__, "This test takes too much time", retval);
y = dummy3(x, iters);
/* Measure one run */
t1 = PAPI_get_real_usec();
y = dummy3(x, iters);
t1 = PAPI_get_real_usec() - t1;
if (t1 < 1000000) /* Scale up execution time to match t2 */
{
iters = iters * (1000000/t1);
printf("Modified iteration count to %d\n\n",iters);
}
/* Now loop through the items one at a time */
ref_measurements(iters, &eventset, events, nevents, refvalues);
/* Now check multiplexed */
if ((retval = PAPI_create_eventset(&eventset)))
test_fail(__FILE__, __LINE__, "PAPI_create_eventset", retval);
/* In Component PAPI, EventSets must be assigned a component index
before you can fiddle with their internals.
0 is always the cpu component */
retval = PAPI_assign_eventset_component(eventset, 0);
if (retval != PAPI_OK)
test_fail(__FILE__, __LINE__, "PAPI_assign_eventset_component", retval);
if ((retval = PAPI_set_multiplex(eventset)))
test_fail(__FILE__, __LINE__, "PAPI_set_multiplex", retval);
if ((retval = PAPI_add_events(eventset, events, nevents)))
test_fail(__FILE__, __LINE__, "PAPI_add_events", retval);
printf("\nPAPI multiplexed measurements:\n");
x = 1.0;
t1 = PAPI_get_real_usec();
if ((retval = PAPI_start(eventset)))
test_fail(__FILE__, __LINE__, "PAPI_start", retval);
y = dummy3(x, iters);
if ((retval = PAPI_stop(eventset, values)))
test_fail(__FILE__, __LINE__, "PAPI_stop", retval);
t2 = PAPI_get_real_usec();
for (j = 0; j < nevents; j++) {
PAPI_get_event_info(events[j], &info);
if (!TESTS_QUIET) {
printf("%20s = ", info.short_descr);
printf(LLDFMT, values[j]);
printf("\n");
}
}
check_values(eventset, events, nevents, values, refvalues);
if ((retval = PAPI_remove_events(eventset, events, nevents)))
test_fail(__FILE__, __LINE__, "PAPI_remove_events", retval);
if ((retval = PAPI_cleanup_eventset(eventset)))
test_fail(__FILE__, __LINE__, "PAPI_cleanup_eventset", retval);
if ((retval = PAPI_destroy_eventset(&eventset)))
test_fail(__FILE__, __LINE__, "PAPI_destroy_eventset", retval);
eventset = PAPI_NULL;
/* Now loop through the items one at a time */
ref_measurements(iters, &eventset, events, nevents, refvalues);
check_values(eventset, events, nevents, values, refvalues);
test_pass(__FILE__, NULL, 0);
return 0;
}
/**
* facq_net_receive:
* @skt: A connected #GSocket object.
* @buf: A pointer to a free memory area.
* @size: The size of the memory area pointed by @buf.
* @retry: The number of times to retry receiving data until @buf is full, or 0.
* if 0 the function will use an automatic number of retries, and won't return
* until size bytes are read.
* @err: A #GError, it will be set in case of error if not %NULL.
*
* Receives @size bytes, in the memory area pointed by @buf, from the connect
* socket @skt, using at most @retry retries.
*
* Returns: The number of bytes received if successful, 0 if disconnected, -1 in case of error,
* -2 in case of timeout, -3 if wrong parameters are passed to the function.
*/
gssize facq_net_receive(GSocket *skt,gchar *buf,gsize size,guint retry,GError **err)
{
guint retries = 0;
gsize to_read = 0, remaining = 0;
gssize ret = 0, total = 0;
GError *local_err = NULL;
if(!check_values(skt,buf,size)) {
if(err != NULL)
g_set_error_literal(err,G_IO_ERROR,
G_IO_ERROR_FAILED,"Can't receive any data");
return -3;
}
if(retry == 0)
retry = G_MAXUINT;
to_read = 0;
remaining = size;
for(retries = 0; retries < retry && total < size; retries++) {
#if ENABLE_DEBUG
facq_log_write_v(FACQ_LOG_MSG_TYPE_DEBUG,"Receiving data retry=%u",retries);
#endif
ret = g_socket_receive(skt,&buf[to_read],remaining,NULL,&local_err);
#if ENABLE_DEBUG
facq_log_write_v(FACQ_LOG_MSG_TYPE_DEBUG,
"g_socket_receive ret=%"G_GSSIZE_FORMAT,
ret);
#endif
switch(ret) {
case 0:
facq_log_write_v(FACQ_LOG_MSG_TYPE_INFO,
"Disconnected");
return 0;
break;
case -1:
if(local_err) {
facq_log_write_v(FACQ_LOG_MSG_TYPE_ERROR,
"%s",local_err->message);
if(err != NULL)
g_propagate_error(err,local_err);
return -1;
}
else {
if(err != NULL)
g_set_error_literal(err,G_IO_ERROR,
G_IO_ERROR_FAILED,"Error receiving data");
facq_log_write_v(FACQ_LOG_MSG_TYPE_ERROR,
"Unknown error receiving data");
return -1;
}
break;
default:
total += ret;
to_read += ret;
remaining = size - total;
if(total == size)
break;
}
}
if(total != size) {
if(err != NULL)
g_set_error_literal(err,G_IO_ERROR,
G_IO_ERROR_TIMED_OUT,"Operation timed out");
return -2;
}
return total;
}
int
heapCheck(HEAP h)
{
return check_values((Heap*)h,0,0);
}
void runTest(int prec1, int prec2, int loc1, int loc2, int matrix)
{
int status = 0, type;
oskar_Mem *beam1, *beam2;
oskar_Timer *timer1, *timer2;
double time1, time2;
// Create the timers.
timer1 = oskar_timer_create(loc1 == OSKAR_GPU ?
OSKAR_TIMER_CUDA : OSKAR_TIMER_NATIVE);
timer2 = oskar_timer_create(loc2 == OSKAR_GPU ?
OSKAR_TIMER_CUDA : OSKAR_TIMER_NATIVE);
// Run first part.
type = prec1 | OSKAR_COMPLEX;
if (matrix) type |= OSKAR_MATRIX;
beam1 = oskar_mem_create(type, loc1, num_sources, &status);
oskar_mem_clear_contents(beam1, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
createTestData(prec1, loc1, matrix);
oskar_timer_start(timer1);
oskar_evaluate_cross_power(num_sources, num_stations,
jones, 0, beam1, &status);
time1 = oskar_timer_elapsed(timer1);
destroyTestData();
ASSERT_EQ(0, status) << oskar_get_error_string(status);
// Run second part.
type = prec2 | OSKAR_COMPLEX;
if (matrix) type |= OSKAR_MATRIX;
beam2 = oskar_mem_create(type, loc2, num_sources, &status);
oskar_mem_clear_contents(beam2, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
createTestData(prec2, loc2, matrix);
oskar_timer_start(timer2);
oskar_evaluate_cross_power(num_sources, num_stations,
jones, 0, beam2, &status);
time2 = oskar_timer_elapsed(timer2);
destroyTestData();
ASSERT_EQ(0, status) << oskar_get_error_string(status);
// Destroy the timers.
oskar_timer_free(timer1);
oskar_timer_free(timer2);
// Compare results.
check_values(beam1, beam2);
// Free memory.
oskar_mem_free(beam1, &status);
oskar_mem_free(beam2, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
// Record properties for test.
RecordProperty("JonesType", matrix ? "Matrix" : "Scalar");
RecordProperty("Prec1", prec1 == OSKAR_SINGLE ? "Single" : "Double");
RecordProperty("Loc1", loc1 == OSKAR_CPU ? "CPU" : "GPU");
RecordProperty("Time1_ms", int(time1 * 1000));
RecordProperty("Prec2", prec2 == OSKAR_SINGLE ? "Single" : "Double");
RecordProperty("Loc2", loc2 == OSKAR_CPU ? "CPU" : "GPU");
RecordProperty("Time2_ms", int(time2 * 1000));
#ifdef ALLOW_PRINTING
// Print times.
printf(" > %s.\n", matrix ? "Matrix" : "Scalar");
printf(" %s precision %s: %.2f ms, %s precision %s: %.2f ms\n",
prec1 == OSKAR_SINGLE ? "Single" : "Double",
loc1 == OSKAR_CPU ? "CPU" : "GPU",
time1 * 1000.0,
prec2 == OSKAR_SINGLE ? "Single" : "Double",
loc2 == OSKAR_CPU ? "CPU" : "GPU",
time2 * 1000.0);
#endif
}
