bool check_priority() { // true if battle, false if surrender
if (PLAYER1_ACTION == SURRENDER_A || PLAYER2_ACTION == SURRENDER_A) {
return false;
}
int player1_priority = get_priority(PLAYER1);
int player2_priority = get_priority(PLAYER2);
if (player1_priority == player2_priority) {
int player1_speed = calc_speed(PLAYER1_POKEMON);
int player2_speed = calc_speed(PLAYER2_POKEMON);
if (player1_speed == player2_speed) {
set_curr((roll(.5) ? PLAYER1 : PLAYER2));
return true;
} else {
set_curr((player1_speed > player2_speed ? PLAYER1 : PLAYER2));
return true;
}
} else {
set_curr((player1_priority > player2_priority ? PLAYER1 : PLAYER2));
return true;
}
return true;
}
void soc_common_pcmcia_get_timing(struct soc_pcmcia_socket *skt,
struct soc_pcmcia_timing *timing)
{
timing->io =
calc_speed(skt->spd_io, MAX_IO_WIN, SOC_PCMCIA_IO_ACCESS);
timing->mem =
calc_speed(skt->spd_mem, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS);
timing->attr =
calc_speed(skt->spd_attr, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS);
}
static void draw_background(int pixel_ref_size, double screen_ratio)
{
static int first=0;
static double x_first=UNDEF_COORD;
double move;
int current=first;
double x_current=x_first;
double size;
int i;
if(x_first == UNDEF_COORD ) {
x_first=1.0;
}
/* Fill array */
for(i=0; i<MAX_IMG; i++) {
if( bg[i] == NULL ) {
break;
}
}
if( i < MAX_IMG ) {
bg[i] = loader_get_img(loader);
}
current = 0;
if(bg[current]==NULL) {
return;
}
while(x_current < screen_ratio ) {
printd(DEBUG_SDL,"Copying background %d to screen\n",current);
/* Calc move in pixel */
size = 1.0;
if( bg[current]->ratio > 1.0 ) {
size = bg[current]->ratio;
}
opengl_blit(pixel_ref_size,x_current,0, bg[current],size,0.0);
x_current = x_current + bg[current]->ratio;
current = (current+1) % MAX_IMG;
if(bg[current] == NULL) {
current = 0;
}
}
if(-x_first > bg[0]->ratio) {
x_first = x_first + bg[0]->ratio;
opengl_delete_texture(bg[0]);
for( i=0; i<MAX_IMG-1; i++) {
bg[i] = bg[i+1];
}
bg[i] = NULL;
}
move = calc_speed();
x_first-=move;
}
void DispatchDownloader::handle_open(
boost::system::error_code const & ec)
{
LOG_INFO("[handle_open] ec:" << ec.message());
boost::system::error_code ec1 = ec;
if (!ec1) {
dispatcher_->setup(-1, *sink_, ec1);
}
if (ec1) {
response(ec1);
return;
}
opened_ = true;
ppbox::dispatch::SeekRange range;
range.type = ppbox::dispatch::SeekRange::byte;
file_sink_->file_stream().seekp(0, std::ios::end);
range.beg = file_sink_->file_stream().tellp();
if (range.beg == 0) {
range.type = ppbox::dispatch::SeekRange::none;
}
calc_speed(range.beg);
dispatcher_->async_play(
range,
ppbox::dispatch::response_t(),
boost::bind(&DispatchDownloader::handle_play, this, _1));
}
bool DispatchDownloader::get_statictis(
DownloadStatistic & stat,
boost::system::error_code & ec)
{
if (!opened_) {
stat.total_size = 0;
stat.finish_size = 0;
stat.speed = 0;
ec.clear();
return true;
}
ppbox::data::StreamStatus info;
if (!dispatcher_->get_stream_status(info, ec))
return false;
stat.total_size = info.byte_range.end;
stat.finish_size = info.byte_range.pos;
stat.speed = calc_speed(info.byte_range.pos);
return true;
}
static int mt9v011_s_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *parms)
{
struct v4l2_captureparm *cp = &parms->parm.capture;
struct v4l2_fract *tpf = &cp->timeperframe;
u16 speed;
if (parms->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
return -EINVAL;
if (cp->extendedmode != 0)
return -EINVAL;
speed = calc_speed(sd, tpf->numerator, tpf->denominator);
mt9v011_write(sd, R0A_MT9V011_CLK_SPEED, speed);
v4l2_dbg(1, debug, sd, "Setting speed to %d\n", speed);
/* Recalculate and update fps info */
calc_fps(sd, &tpf->numerator, &tpf->denominator);
return 0;
}
static int __init mtd_speedtest_init(void)
{
int err, i, blocks, j, k;
long speed;
uint64_t tmp;
printk(KERN_INFO "\n");
printk(KERN_INFO "=================================================\n");
if (dev < 0) {
printk(PRINT_PREF "Please specify a valid mtd-device via module paramter\n");
printk(KERN_CRIT "CAREFUL: This test wipes all data on the specified MTD device!\n");
return -EINVAL;
}
if (count)
printk(PRINT_PREF "MTD device: %d count: %d\n", dev, count);
else
printk(PRINT_PREF "MTD device: %d\n", dev);
mtd = get_mtd_device(NULL, dev);
if (IS_ERR(mtd)) {
err = PTR_ERR(mtd);
printk(PRINT_PREF "error: cannot get MTD device\n");
return err;
}
if (mtd->writesize == 1) {
printk(PRINT_PREF "not NAND flash, assume page size is 512 "
"bytes.\n");
pgsize = 512;
} else
pgsize = mtd->writesize;
tmp = mtd->size;
do_div(tmp, mtd->erasesize);
ebcnt = tmp;
pgcnt = mtd->erasesize / pgsize;
printk(PRINT_PREF "MTD device size %llu, eraseblock size %u, "
"page size %u, count of eraseblocks %u, pages per "
"eraseblock %u, OOB size %u\n",
(unsigned long long)mtd->size, mtd->erasesize,
pgsize, ebcnt, pgcnt, mtd->oobsize);
if (count > 0 && count < ebcnt)
ebcnt = count;
err = -ENOMEM;
iobuf = kmalloc(mtd->erasesize, GFP_KERNEL);
if (!iobuf) {
printk(PRINT_PREF "error: cannot allocate memory\n");
goto out;
}
simple_srand(1);
set_random_data(iobuf, mtd->erasesize);
err = scan_for_bad_eraseblocks();
if (err)
goto out;
err = erase_whole_device();
if (err)
goto out;
/* Write all eraseblocks, 1 eraseblock at a time */
printk(PRINT_PREF "testing eraseblock write speed\n");
start_timing();
for (i = 0; i < ebcnt; ++i) {
if (bbt[i])
continue;
err = write_eraseblock(i);
if (err)
goto out;
cond_resched();
}
stop_timing();
speed = calc_speed();
printk(PRINT_PREF "eraseblock write speed is %ld KiB/s\n", speed);
/* Read all eraseblocks, 1 eraseblock at a time */
printk(PRINT_PREF "testing eraseblock read speed\n");
start_timing();
for (i = 0; i < ebcnt; ++i) {
if (bbt[i])
continue;
err = read_eraseblock(i);
if (err)
goto out;
cond_resched();
}
stop_timing();
speed = calc_speed();
printk(PRINT_PREF "eraseblock read speed is %ld KiB/s\n", speed);
err = erase_whole_device();
if (err)
goto out;
/* Write all eraseblocks, 1 page at a time */
printk(PRINT_PREF "testing page write speed\n");
start_timing();
for (i = 0; i < ebcnt; ++i) {
if (bbt[i])
continue;
err = write_eraseblock_by_page(i);
if (err)
goto out;
cond_resched();
}
stop_timing();
speed = calc_speed();
printk(PRINT_PREF "page write speed is %ld KiB/s\n", speed);
/* Read all eraseblocks, 1 page at a time */
printk(PRINT_PREF "testing page read speed\n");
start_timing();
for (i = 0; i < ebcnt; ++i) {
if (bbt[i])
continue;
err = read_eraseblock_by_page(i);
if (err)
goto out;
cond_resched();
}
stop_timing();
speed = calc_speed();
printk(PRINT_PREF "page read speed is %ld KiB/s\n", speed);
err = erase_whole_device();
if (err)
goto out;
/* Write all eraseblocks, 2 pages at a time */
printk(PRINT_PREF "testing 2 page write speed\n");
start_timing();
for (i = 0; i < ebcnt; ++i) {
if (bbt[i])
continue;
err = write_eraseblock_by_2pages(i);
if (err)
goto out;
cond_resched();
}
stop_timing();
speed = calc_speed();
printk(PRINT_PREF "2 page write speed is %ld KiB/s\n", speed);
/* Read all eraseblocks, 2 pages at a time */
printk(PRINT_PREF "testing 2 page read speed\n");
start_timing();
for (i = 0; i < ebcnt; ++i) {
if (bbt[i])
continue;
err = read_eraseblock_by_2pages(i);
if (err)
goto out;
cond_resched();
}
stop_timing();
speed = calc_speed();
printk(PRINT_PREF "2 page read speed is %ld KiB/s\n", speed);
/* Erase all eraseblocks */
printk(PRINT_PREF "Testing erase speed\n");
start_timing();
for (i = 0; i < ebcnt; ++i) {
if (bbt[i])
continue;
err = erase_eraseblock(i);
if (err)
goto out;
cond_resched();
}
stop_timing();
speed = calc_speed();
printk(PRINT_PREF "erase speed is %ld KiB/s\n", speed);
/* Multi-block erase all eraseblocks */
for (k = 1; k < 7; k++) {
blocks = 1 << k;
printk(PRINT_PREF "Testing %dx multi-block erase speed\n",
blocks);
start_timing();
for (i = 0; i < ebcnt; ) {
for (j = 0; j < blocks && (i + j) < ebcnt; j++)
if (bbt[i + j])
break;
if (j < 1) {
i++;
continue;
}
err = multiblock_erase(i, j);
if (err)
goto out;
cond_resched();
i += j;
}
stop_timing();
speed = calc_speed();
printk(PRINT_PREF "%dx multi-block erase speed is %ld KiB/s\n",
blocks, speed);
}
printk(PRINT_PREF "finished\n");
out:
kfree(iobuf);
kfree(bbt);
put_mtd_device(mtd);
if (err)
printk(PRINT_PREF "error %d occurred\n", err);
printk(KERN_INFO "=================================================\n");
return err;
}
qreal PacketBuffer::bufferSpeedInBytes() const
{
return calc_speed(true);
}
qreal PacketBuffer::bufferSpeed() const
{
return calc_speed(false);
}
static int __init fsspeed_init(void)
{
int err, i;
long speed;
struct file *fp;
mm_segment_t fs;
printk(KERN_INFO "\n");
printk(KERN_INFO "=================================================\n");
printk(PRINT_PREF "rw %d PAGES using file: %s\n", count, fname);
err = -ENOMEM;
iobuf = kmalloc(PAGE_SIZE, GFP_KERNEL);
if (!iobuf) {
printk(PRINT_PREF "error: cannot allocate memory\n");
goto out;
}
simple_srand(1);
set_random_data(iobuf, PAGE_SIZE);
fp = filp_open(fname, O_RDWR|O_CREAT, 0600);
if (IS_ERR(fp)) {
printk("open file %s failed.\n", fname);
err = PTR_ERR(fp);
goto out;
}
/* Write all eraseblocks, 1 eraseblock at a time */
printk(PRINT_PREF "testing file system write speed\n");
fs = get_fs();
set_fs(KERNEL_DS);
start_timing();
for (i = 0; i < count; ++i) {
err = vfs_write(fp, iobuf, PAGE_SIZE, &fp->f_pos);
if (err < 0)
goto out2;
// cond_resched();
}
stop_timing();
speed = calc_speed();
printk(PRINT_PREF "write speed is %ld KiB/s\n", speed);
vfs_fsync(fp, fp->f_path.dentry, 0);
invalidate_mapping_pages(fp->f_dentry->d_inode->i_mapping, 0, -1);
vfs_llseek(fp, 0, SEEK_SET);
/* Read all eraseblocks, 1 eraseblock at a time */
printk(PRINT_PREF "testing file system read speed\n");
start_timing();
for (i = 0; i < count; ++i) {
err = vfs_read(fp, iobuf, PAGE_SIZE, &fp->f_pos);
if (err < 0)
goto out2;
// cond_resched();
}
stop_timing();
speed = calc_speed();
printk(PRINT_PREF "read speed is %ld KiB/s\n", speed);
printk(PRINT_PREF "finished\n");
err = 0;
out2:
filp_close(fp, NULL);
set_fs(fs);
out:
kfree(iobuf);
if (err)
printk(PRINT_PREF "error %d occurred\n", err);
printk(KERN_INFO "=================================================\n");
return err;
}
static int __init mtd_speedtest_init(void)
{
int err, i;
long speed;
uint64_t tmp;
printk(KERN_INFO "\n");
printk(KERN_INFO "=================================================\n");
printk(PRINT_PREF "MTD device: %d\n", dev);
mtd = get_mtd_device(NULL, dev);
if (IS_ERR(mtd)) {
err = PTR_ERR(mtd);
printk(PRINT_PREF "error: cannot get MTD device\n");
return err;
}
if (mtd->writesize == 1) {
printk(PRINT_PREF "not NAND flash, assume page size is 512 "
"bytes.\n");
pgsize = 512;
} else
pgsize = mtd->writesize;
tmp = mtd->size;
do_div(tmp, mtd->erasesize);
ebcnt = tmp;
pgcnt = mtd->erasesize / pgsize;
printk(PRINT_PREF "MTD device size %llu, eraseblock size %u, "
"page size %u, count of eraseblocks %u, pages per "
"eraseblock %u, OOB size %u\n",
(unsigned long long)mtd->size, mtd->erasesize,
pgsize, ebcnt, pgcnt, mtd->oobsize);
err = -ENOMEM;
iobuf = kmalloc(mtd->erasesize, GFP_KERNEL);
if (!iobuf) {
printk(PRINT_PREF "error: cannot allocate memory\n");
goto out;
}
simple_srand(1);
set_random_data(iobuf, mtd->erasesize);
err = scan_for_bad_eraseblocks();
if (err)
goto out;
err = erase_whole_device();
if (err)
goto out;
/* Write all eraseblocks, 1 eraseblock at a time */
printk(PRINT_PREF "testing eraseblock write speed\n");
start_timing();
for (i = 0; i < ebcnt; ++i) {
if (bbt[i])
continue;
err = write_eraseblock(i);
if (err)
goto out;
cond_resched();
}
stop_timing();
speed = calc_speed();
printk(PRINT_PREF "eraseblock write speed is %ld KiB/s\n", speed);
/* Read all eraseblocks, 1 eraseblock at a time */
printk(PRINT_PREF "testing eraseblock read speed\n");
start_timing();
for (i = 0; i < ebcnt; ++i) {
if (bbt[i])
continue;
err = read_eraseblock(i);
if (err)
goto out;
cond_resched();
}
stop_timing();
speed = calc_speed();
printk(PRINT_PREF "eraseblock read speed is %ld KiB/s\n", speed);
err = erase_whole_device();
if (err)
goto out;
/* Write all eraseblocks, 1 page at a time */
printk(PRINT_PREF "testing page write speed\n");
start_timing();
for (i = 0; i < ebcnt; ++i) {
if (bbt[i])
continue;
err = write_eraseblock_by_page(i);
if (err)
goto out;
cond_resched();
}
stop_timing();
speed = calc_speed();
printk(PRINT_PREF "page write speed is %ld KiB/s\n", speed);
/* Read all eraseblocks, 1 page at a time */
printk(PRINT_PREF "testing page read speed\n");
start_timing();
for (i = 0; i < ebcnt; ++i) {
if (bbt[i])
continue;
err = read_eraseblock_by_page(i);
if (err)
goto out;
cond_resched();
}
stop_timing();
speed = calc_speed();
printk(PRINT_PREF "page read speed is %ld KiB/s\n", speed);
err = erase_whole_device();
if (err)
goto out;
/* Write all eraseblocks, 2 pages at a time */
printk(PRINT_PREF "testing 2 page write speed\n");
start_timing();
for (i = 0; i < ebcnt; ++i) {
if (bbt[i])
continue;
err = write_eraseblock_by_2pages(i);
if (err)
goto out;
cond_resched();
}
stop_timing();
speed = calc_speed();
printk(PRINT_PREF "2 page write speed is %ld KiB/s\n", speed);
/* Read all eraseblocks, 2 pages at a time */
printk(PRINT_PREF "testing 2 page read speed\n");
start_timing();
for (i = 0; i < ebcnt; ++i) {
if (bbt[i])
continue;
err = read_eraseblock_by_2pages(i);
if (err)
goto out;
cond_resched();
}
stop_timing();
speed = calc_speed();
printk(PRINT_PREF "2 page read speed is %ld KiB/s\n", speed);
/* Erase all eraseblocks */
printk(PRINT_PREF "Testing erase speed\n");
start_timing();
for (i = 0; i < ebcnt; ++i) {
if (bbt[i])
continue;
err = erase_eraseblock(i);
if (err)
goto out;
cond_resched();
}
stop_timing();
speed = calc_speed();
printk(PRINT_PREF "erase speed is %ld KiB/s\n", speed);
printk(PRINT_PREF "finished\n");
out:
kfree(iobuf);
kfree(bbt);
put_mtd_device(mtd);
if (err)
printk(PRINT_PREF "error %d occurred\n", err);
printk(KERN_INFO "=================================================\n");
return err;
}
