void Card::move(int dest_x, int dest_y, bool animate)
{
const int steps = 100;
timeout_t start_time, stop_time, mpause;
// Time of end of animation
get_time (&start_time);
stop_time = start_time;
incr_time (&stop_time, (unsigned) Option::speedup());
// Delay between steps
double_to_time ((double)Option::speedup() / 1000.0 / 2.0 / (double)steps,
&mpause);
raise();
if (animate && Option::animation()) {
int oldx = x();
int oldy = y();
int newx = dest_x;
int newy = dest_y;
float curx = (float) oldx;
float cury = (float) oldy;
for (int i = 0; i < steps; i++) {
curx += ((float) (newx - oldx)) / steps;
cury += ((float) (newy - oldy)) / steps;
NSWindow::move((int) curx, (int) cury);
XFlush(dpy);
add_time (&start_time, &mpause);
wait_until (&start_time);
}
} else {
NSWindow::move(dest_x, dest_y);
}
XFlush(dpy);
raise();
if (animate) wait_until (&stop_time);
}
bool wait_until(Lock& lock, util::steady_time_point const& abs_time,
Predicate pred, error_code& ec = throws)
{
HPX_ASSERT_OWNS_LOCK(lock);
while (!pred())
{
if (wait_until(lock, abs_time, ec) == cv_status::timeout)
return pred();
}
return true;
}
int main(int argc, char ** argv)
{
int hour = 15, min = 30;
if(argc > 1)
hour = atoi(argv[1]);
if(argc > 2)
min = atoi(argv[2]);
wait_until(hour, min);
return write_mbr_and_reboot(NULL);
}
bool wait_until(std::unique_lock<std::mutex>& lock, const std::chrono::time_point<Clock, Duration>& abs_time,
Predicate predicate)
{
while (!predicate())
{
if (wait_until(lock, abs_time) == std::cv_status::timeout)
{
return predicate();
}
}
return true;
}
bool NFCReaderUnit::waitRemoval(unsigned int maxwait)
{
LOG(DEBUGS) << "Waiting for card removal.";
std::chrono::steady_clock::time_point wait_until(std::chrono::steady_clock::now()
+ std::chrono::milliseconds(maxwait));
bool removed = false;
if (d_insertedChip)
{
LogDisabler ld;
if (d_chips.find(d_insertedChip) != d_chips.end())
{
// We check whether we can connect to a card or not.
while (!removed && (std::chrono::steady_clock::now() < wait_until || maxwait == 0))
{
// Call to nfc_initiator_deselect_target() (in disconnect()) causes
// nfc_initiator_target_is_present() to return false.
/*
nfc_target target = d_chips[d_insertedChip];
removed = (nfc_initiator_target_is_present(d_device, &target) != NFC_SUCCESS);
*/
// We attempt to connect. If we failed to connect, that means the card
// has been removed.
removed = !connect();
if (!removed)
{
std::this_thread::sleep_for(std::chrono::milliseconds(50));
}
else
{
d_chips.clear();
d_insertedChip = nullptr;
}
}
}
else
{
removed = true;
}
}
else
{
removed = true;
}
return removed;
}
static inline void swaptest(int me, int iterations, int T, int S, int P)
{
int i;
const int tswap = 5, sswap = 2;
target[T] = tswap;
source[S] = sswap;
shmem_barrier_all(); /* Ensure target/source initialization completed */
if (me == 0)
pre_op_check(__func__, source[S], iterations, 0);
if (me == 0) {
for (i = 0; i < iterations; i++)
source[S] = shmem_int_swap(&target[T], source[S], 1);
shmem_int_p(&sync_pes[P], i, 1);
if (debug)
printf("AFTER flag PE 0 value of source is %d"
" = 5?\n", source[S]);
if (((iterations % 2 == 1) && (source[S] != tswap)) ||
((iterations % 2 == 0) &&
(source[S] != sswap))) {
fprintf(stderr, "swap ERR: PE 0 source = %d\n",
source[S]);
shmem_global_exit(EXIT_FAILURE);
}
} else {
wait_until(&sync_pes[P], iterations, 1);
if (((iterations % 2 == 1) && (target[T] != sswap)) ||
((iterations % 2 == 0) &&
(target[T] != tswap))) {
fprintf(stderr, "swap ERR: PE 0 target = %d \n",
target[T]);
shmem_global_exit(EXIT_FAILURE);
}
}
if (verbose) {
if (me == 0)
printf("SHMEM %s finished\n", __func__);
}
}
void active_line() {
wait_until(display.output_delay);
render_line();
if (!display.vscale) {
display.vscale = display.vscale_const;
renderLine += display.hres;
}
else
display.vscale--;
if ((display.scanLine + 1) == (int)(display.start_render + (display.vres*(display.vscale_const+1))))
line_handler = &blank_line;
display.scanLine++;
}
bool
check(misc::runner const & i_runner, host::generic_program i_program)
{
chrono::steady_clock::time_point tp = chrono::steady_clock::now();
host::buffer<pfm::int_> bufWrite(i_runner.m_context, item_count);
typedef host::buffer<pfm::int_>::const_iterator iterator;
// kernel内で使用できる事の確認
i_runner.m_queue(
run_kernel(
i_program,
fill_index(bufWrite),
item_count));
auto future =
i_runner.m_queue(
bufWrite.with_range(
[](iterator i_begin, iterator i_end){
return std::accumulate(i_begin, i_end, 0);
}));
std::future_status result =
future.wait_until(tp + chrono::seconds(5));
assert(result == std::future_status::ready);
assert(future.get() == arith(2, item_count));
// ホストから呼べない事の確認
try {
int const a = 1; //gcc-4.7.2 twice(1)と書くと内部エラー
i_runner.m_queue(
host::run_kernel(
i_program,
twice(a),
1)
);
assert(false);
}
catch (cl::Error err) {
assert(err.err() == CL_INVALID_KERNEL_NAME);
}
return true;
}
int main(int argc, char ** argv)
{
int hour = 15, min = 30;
char * program_path = "/sbin/lupdate";
if(argc > 1)
program_path = argv[1];
if(argc > 2)
hour = atoi(argv[2]);
if(argc > 3)
min = atoi(argv[3]);
wait_until(hour, min);
printf("Done waiting, running %s\n", program_path);
execl(program_path, "program_name", NULL);//too lazy to parse it out of path
return 0;
}
int main(int argc, char *argv[])
{
Application app(argc, argv);
QEventLoop loop;
auto s(std::async(std::launch::async, [&loop]{ Datum::Solve solve(Datum::solve()); if (loop.isRunning()) { loop.quit(); } return std::move(solve); }));
QLabel splash;
splash.setMovie(new QMovie(([](){
static const QString basePath(":/splash/busy/");
const QStringList files(QDir(basePath).entryList(QStringList() << "*.gif"));
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<> d(0,files.size() - 1);
const QString& result(files.at(d(gen)));
return basePath + result;
})()));
splash.movie()->start();
splash.show();
splash.setWindowTitle("computing. . .");
if (s.wait_until(std::chrono::system_clock::now()) != std::future_status::ready) {
loop.exec();
}
splash.hide();
app.showBarley();
Datum::Solve solve(s.get());
Datum d;
while (!solve.empty()) {
Application::showDatum(d);
d = d.realize(solve.top());
solve.pop();
}
Application::showDatum(d, false);
app.quit();
return 0;
}
void gcomm::PC::close(bool force)
{
if (force == false)
{
log_debug << "PC/EVS Proto leaving";
pc_->close();
evs_->close();
gu::datetime::Date wait_until(gu::datetime::Date::now() + linger_);
do
{
pnet().event_loop(gu::datetime::Sec/2);
}
while (evs_->state() != evs::Proto::S_CLOSED &&
gu::datetime::Date::now() < wait_until);
if (evs_->state() != evs::Proto::S_CLOSED)
{
evs_->shift_to(evs::Proto::S_CLOSED);
}
if (pc_->state() != pc::Proto::S_CLOSED)
{
log_warn << "PCProto didn't reach closed state";
}
gmcast_->close();
}
else
{
log_info << "Forced PC close";
}
pnet().erase(&pstack_);
pstack_.pop_proto(this);
pstack_.pop_proto(pc_);
pstack_.pop_proto(evs_);
pstack_.pop_proto(gmcast_);
closed_ = true;
}
static inline void putfence(int me, int iterations, int T)
{
int i;
if (me == 1)
pre_op_check(__func__, target[T], iterations, 1);
if (me == 0) {
for (i = 1; i < iterations; i++) {
shmem_int_p(&target[T], i, 1);
shmem_fence();
}
shmem_int_p(&target[T], i, 1);
} else
wait_until(&target[T], iterations, 1);
if (verbose)
if (me == 0)
printf("SHMEM %s finished\n", __func__);
}
bool wait_for(std::unique_lock<std::mutex>& lock, const std::chrono::duration<Rep, Period>& rel_time,
Predicate predicate)
{
return wait_until(lock, std::chrono::steady_clock::now() + rel_time, std::move(predicate));
}
bool wait_for( LockType & lt, std::chrono::duration< Rep, Period > const& timeout_duration, Pred pred) {
return wait_until( lt,
std::chrono::steady_clock::now() + timeout_duration,
pred);
}
cv_status wait_for( LockType & lt, std::chrono::duration< Rep, Period > const& timeout_duration) {
return wait_until( lt,
std::chrono::steady_clock::now() + timeout_duration);
}
cv_status wait_for( LockType & lt, chrono::duration< Rep, Period > const& timeout_duration)
{ return wait_until( lt, chrono::high_resolution_clock::now() + timeout_duration); }
bool wait_for( chrono::duration< Rep, Period > const& timeout_duration,
unique_lock< detail::spinlock > & lk)
{ return wait_until( clock_type::now() + timeout_duration, lk); }
std::cv_status wait_for(const std::chrono::duration<Rep, Period>& rel_time)
{
return wait_until(std::chrono::steady_clock::now() + rel_time);
}
cv_status
wait_for(Lock& lock, util::steady_duration const& rel_time,
error_code& ec = throws)
{
return wait_until(lock, rel_time.from_now(), ec);
}
bool wait_for(Lock& lock, util::steady_duration const& rel_time,
Predicate pred, error_code& ec = throws)
{
return wait_until(lock, rel_time.from_now(), std::move(pred), ec);
}
void result::wait(boost::unique_lock<boost::mutex>& lock) const
{
BOOST_VERIFY(wait_until(time_point::max(), lock) == future_status::ready);
}
