void
nv_srand(unsigned int seed)
{
int i;
tinymt32_init(&g_state[0], seed);
for (i = 1; i < NV_RAND_THREAD_MAX; ++i) {
tinymt32_init(&g_state[i], seed + i);
}
}
void
nv_srand_time(void)
{
uint32_t seed = (uint32_t)(time(NULL) & 0xffffffff);
int i;
tinymt32_init(&g_state[0], seed);
for (i = 1; i < NV_RAND_THREAD_MAX; ++i) {
tinymt32_init(&g_state[i], seed + i);
}
}
void
nv_rand_init(void)
{
int i;
for (i = 0; i < NV_RAND_THREAD_MAX; ++i) {
tinymt32_init_param(&g_state[i],
0x09f6013eU,
0xf848fe13U,
0x52a0f5ffU);
}
tinymt32_init(&g_state[0], 11);
for (i = 1; i < NV_RAND_THREAD_MAX; ++i) {
tinymt32_init(&g_state[i], 11 + i);
}
}
int main(int argc, char *argv[])
{
//TODO: READ IN NAME OF INPUT FILE
// int i;
// for (i = 1; i < argc; i++)
// INPUT_FILENAME[i] = argv[i];
// init_board();
int move[2], i;
uint32_t seed = getpid();
tinymt32_init(&state, seed);
for(i = 0; i < 60; i++)
moves[i] = -1;
i = 0;
while(2 * i < argc - 1)
{
moves[i * 2] = atoi(argv[i * 2 + 1]);
moves[i * 2 + 1] = atoi(argv[i * 2 + 1 + 1]);
if(i % 2)
board[moves[i * 2]][moves[i * 2 + 1]] = INF;
else
board[moves[i * 2]][moves[i * 2 + 1]] = -INF;
i++;
NUM_MOVES_REMAINING--;
next_to_set = next_to_set > 0 ? 0 : 1;
}
init_board();
if (next_to_set)
alpha_better(move, 5, 0);
else
alpha_better(move, 4, 0);
printf("%d %d %d", move[0], move[1], our_area());
return 0;
}
int rnd_seed(lua_State *L)
{
int result = 0;
if (lua_gettop(L) == 1 && lua_isnumber(L, 1))
{
unsigned int seed = lua_tounsigned(L, 1);
tinymt32_init(&random_handler, seed);
result = 1;
}
lua_pushboolean(L, result);
return 1;
}
void fixed_jump(tinymt32_t * tiny, const char * poly_str,
uint64_t lower_step,
uint64_t upper_step,
uint32_t seed)
{
tinymt32_t new_tiny_z;
tinymt32_t * new_tiny = &new_tiny_z;
char jump_str[100];
polynomial charcteristic;
polynomial jump_poly;
polynomial tee;
strtop(&charcteristic, poly_str);
tee.ar[0] = 2;
tee.ar[1] = 0;
polynomial_power_mod(&jump_poly,
&tee,
lower_step,
upper_step,
&charcteristic);
memset(jump_str, 0, sizeof(jump_str));
ptostr(jump_str, &jump_poly);
printf("lower_step: %"PRIu64" upper_step:%"PRIu64"\n",
lower_step, upper_step);
printf("jump_poly:%s\n", jump_str);
printf("check data:\n");
printf("seed = %u\n", seed);
tinymt32_init(tiny, seed);
*new_tiny = *tiny;
printf("before:\n");
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 5; j++) {
printf("%10"PRIu32" ", tinymt32_generate_uint32(tiny));
}
printf("\n");
}
/* period jump */
tinymt32_jump(new_tiny,
lower_step,
upper_step,
poly_str);
printf("after:\n");
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 5; j++) {
printf("%10"PRIu32" ", tinymt32_generate_uint32(new_tiny));
}
printf("\n");
}
}
void handle_init() {
uint32_t seed = 4;
tinymt32_init(&rndstate, seed);
window = window_create();
window_set_fullscreen(window, true);
window_stack_push(window, true /* Animated */);
window_set_background_color(window, GColorBlack);
// resource_init_current_app(&APP_RESOURCES);
// Init the layer for the minute display
// layer_init(&layer, window.layer.frame);
// layer.update_proc = &layer_update_callback;
// layer_add_child(&window.layer, &layer);
init_particles();
// setup debugging text layer
GRect window_bounds = layer_get_bounds(window_get_root_layer(window));
text_header_layer = text_layer_create(window_bounds);
text_layer_set_text_color(text_header_layer, GColorWhite);
text_layer_set_background_color(text_header_layer, GColorClear);
text_layer_set_font(text_header_layer, fonts_get_system_font(FONT_KEY_GOTHIC_14));
layer_add_child(window_get_root_layer(window), text_layer_get_layer(text_header_layer));
particle_layer = layer_create(window_bounds);
layer_set_update_proc(particle_layer, update_particles_layer);
layer_add_child(window_get_root_layer(window), particle_layer);
app_timer_register(50, handle_animation_timer, NULL);
app_timer_register(random_in_range(5000, 15000), handle_swarm_timer, NULL);
tick_timer_service_subscribe(MINUTE_UNIT, handle_tick);
accel_tap_service_subscribe(handle_tap);
}
int
main ()
{
unsigned int N_KEYS;
unsigned int N_BATCH;
printf("\n number of keys:");
scanf("%u",&N_KEYS);
printf("\n batch size:");
scanf("%u",&N_BATCH);
tinymt32_t tinymt32;
//initialize random generator
tinymt32_init (&tinymt32, 0);
int iter;
int sec_iter;
int stop;
int counter;
//initialize database
char *errptr = NULL;
leveldb_options_t *options = leveldb_options_create ();
/* initializeOptions */
leveldb_options_set_create_if_missing (options, 1);
leveldb_options_set_write_buffer_size(options,120000000 );
leveldb_options_set_max_open_files(options,800000);
/*open Database */
leveldb_t *db_helper =
leveldb_open (options, "/mnt/database/database_helper", &errptr);
leveldb_t *db = leveldb_open (options, "/mnt/database/database", &errptr);
leveldb_readoptions_t *readoptions = leveldb_readoptions_create ();
leveldb_writeoptions_t *writeoptions = leveldb_writeoptions_create ();
leveldb_writebatch_t* batch=leveldb_writebatch_create();
int64_t diff = zclock_time ();
//write into database_helper
iter=0;
while( iter < N_KEYS)
{
sec_iter=0;
while((iter<N_KEYS) && (sec_iter<N_BATCH)){
unsigned int key = tinymt32_generate_uint32 (&tinymt32);
unsigned int val = tinymt32_generate_uint32 (&tinymt32);
leveldb_writebatch_put (batch,
(const char *) &key, sizeof (int),
(const char *) &val, sizeof (int));
sec_iter++;
iter++;
}
leveldb_write(
db_helper,
writeoptions,
batch,
&errptr);
if(errptr!=NULL){
printf("\n%s",errptr);
}
assert (errptr == NULL);
leveldb_writebatch_clear(batch);
}
leveldb_writebatch_destroy(batch);
diff = zclock_time () - diff;
printf ("\nrandom write: %d", diff);
diff = zclock_time ();
//write sequentially into db
leveldb_iterator_t *liter = leveldb_create_iterator (db_helper,
readoptions);
leveldb_iter_seek_to_first (liter);
while (leveldb_iter_valid (liter))
{
size_t length;
char key[4];
memcpy (key, leveldb_iter_key (liter, &length), 4);
char val[4];
memcpy (val, leveldb_iter_value (liter, &length), 4);
leveldb_iter_get_error (liter, &errptr);
assert (errptr == NULL);
leveldb_put (db,
writeoptions,
(const char *) &key, sizeof (int),
(const char *) &val, sizeof (int), &errptr);
assert (errptr == NULL);
leveldb_iter_next (liter);
}
diff = zclock_time () - diff;
leveldb_close (db);
leveldb_close (db_helper);
}
int
main ()
{
int64_t diff;
unsigned int N_KEYS;
unsigned int TN_KEYS;
int bool_bench;
int N_THREADS;
printf ("\n number of keys to retrieve:");
scanf ("%u", &N_KEYS);
printf ("\n total number of keys:");
scanf ("%u", &TN_KEYS);
printf("\n benchmark randomly inserted database or sequentially inserted database:(1->rand or 0->seq)");
scanf ("%u", &bool_bench);
printf ("\n number of threads:");
scanf ("%u", &N_THREADS);
//zeromq context
zctx_t *ctx = zctx_new ();
//initialize worker args
worker_args_t worker_args;
//initialize rb_tree;
struct dbkey_rb_t dbkey_rb;
RB_INIT (&dbkey_rb);
//initialize keys
unsigned int factor = (unsigned int) N_KEYS / TN_KEYS;
tinymt32_t tinymt32;
/*initializing random generator with the same seed */
tinymt32_init (&tinymt32, 0);
unsigned int *keys =
(unsigned int *) malloc (sizeof (unsigned int) * N_KEYS);
unsigned int sec_iter;
unsigned int iter;
iter = 0;
while (iter < N_KEYS)
{
keys[iter] = tinymt32_generate_uint32 (&tinymt32);
tinymt32_generate_uint32 (&tinymt32);
for (sec_iter = 1; sec_iter < factor; sec_iter++)
{
tinymt32_generate_uint32 (&tinymt32);
tinymt32_generate_uint32 (&tinymt32);
}
iter++;
}
//initialize database
char *errptr = NULL;
leveldb_options_t *options = leveldb_options_create ();
worker_args.options = &options;
/* initialize Options */
leveldb_options_set_create_if_missing (options, 1);
leveldb_options_set_write_buffer_size (options, 62914560);
leveldb_options_set_max_open_files (options, 800000);
//bloom filter
leveldb_filterpolicy_t *bloom = leveldb_filterpolicy_create_bloom (10);
leveldb_options_set_filter_policy (options, bloom);
leveldb_readoptions_t *readoptions = leveldb_readoptions_create ();
worker_args.readoptions = readoptions;
leveldb_writeoptions_t *writeoptions = leveldb_writeoptions_create ();
worker_args.writeoptions = writeoptions;
int rc;
void *push = zsocket_new (ctx, ZMQ_PUSH);
int water = 2000000000;
zsocket_set_hwm (push, water);
rc = zsocket_bind (push, "inproc://bind_point");
//connect
void *pub = zsocket_new (ctx, ZMQ_PUB);
rc = zsocket_bind (pub, "inproc://pub_point");
//connect
void *router = zsocket_new (ctx, ZMQ_ROUTER);
rc = zsocket_bind (router, "inproc://response_point");
//sleep a while
zclock_sleep (1000);
//this assumes some synchronization at the start and end of each new bench
leveldb_t *db_pointer;
worker_args.db = &db_pointer;
//initialize the threads
void *pipe[6];
unsigned char i;
for (i = 0; i < N_THREADS; i++)
{
pipe[i] = zthread_fork (ctx, &worker_fn, (void *) &(worker_args));
}
//sleep a while
zclock_sleep (1000);
if(bool_bench==0){
db_pointer = leveldb_open (options, "/mnt/database/database", &errptr);
benchmark_notree (push, pub, router, N_KEYS, keys,N_THREADS);
printf ("\n benchmark with tree 1st pass");
leveldb_close (db_pointer);
db_pointer = leveldb_open (options, "/mnt/database/database", &errptr);
benchmark_tree (push, pub, router, N_KEYS, keys, dbkey_rb ,N_THREADS);
leveldb_close (db_pointer);
}else{if(bool_bench==1){
db_pointer =
leveldb_open (options, "/mnt/database/database_helper", &errptr);
printf
("\n starting random read without a rb_btree on random inserted database");
benchmark_notree (push, pub, router, N_KEYS, keys,N_THREADS);
leveldb_close (db_pointer);
db_pointer =
leveldb_open (options, "/mnt/database/database_helper", &errptr);
printf ("\n with a tree");
benchmark_tree (push, pub, router, N_KEYS, keys, dbkey_rb,N_THREADS);
leveldb_close (db_pointer);
}
}
}
void mt_random_seed(unsigned long seed)
{
tinymt32_init(&trandom, seed);
}
void mt_random_init(void)
{
tinymt32_init(&trandom, time(NULL));
}
void random_init(uint32_t seed)
{
tinymt32_init(&_random, seed);
}
//---------------------------------------------------------------------------
void RndInit(void)
{
tinymt32_init(&MathTinyMt, 0xF67C129B);
}
//---------------------------------------------------------------------------
void RndInitSeed(u32 num)
{
tinymt32_init(&MathTinyMt, num);
}
