r"""Definition of the DataLoader and it's iterator _DataLoaderIter classes.
To support these two classes, in `./_utils` we define many utility methods and
functions to be run in multiprocessing. E.g., the data loading worker loop is
in `./_utils/worker.py`.
"""
import torch
import multiprocessing as python_multiprocessing
import torch.multiprocessing as multiprocessing
from . import IterableDataset, Sampler, SequentialSampler, RandomSampler, BatchSampler
from . import _utils
from torch._utils import ExceptionWrapper
import threading
import itertools
from torch._six import queue, string_classes
get_worker_info = _utils.worker.get_worker_info
# This function used to be defined in this file. However, it was moved to
# _utils/collate.py. Although it is rather hard to access this from user land
# (one has to explicitly directly `import torch.utils.data.dataloader`), there
# probably is user code out there using it. This aliasing maintains BC in this
# aspect.
default_collate = _utils.collate.default_collate
class _DatasetKind(object):
Map = 0
Iterable = 1
@staticmethod
def create_fetcher(kind, dataset, auto_collation, collate_fn, drop_last):
if kind == _DatasetKind.Map:
return _utils.fetch._MapDatasetFetcher(dataset, auto_collation, collate_fn, drop_last)
else:
return _utils.fetch._IterableDatasetFetcher(dataset, auto_collation, collate_fn, drop_last)
class _InfiniteConstantSampler(Sampler):
r"""Analogous to ``itertools.repeat(None, None)``.
Used as sampler for :class:`~torch.utils.data.IterableDataset`.
"""
def __init__(self):
super(_InfiniteConstantSampler, self).__init__(None)
def __iter__(self):
while True:
yield None
def __len__(self):
# This has to be a TypeError, otherwise, since this is used in
# `len(dataloader)`, `list(dataloader)` will fail.
# see NOTE [ Lack of Default `__len__` in Python Abstract Base Classes ]
raise TypeError('Cannot determine the DataLoader length of a IterableDataset')
[docs]class DataLoader(object):
r"""
Data loader. Combines a dataset and a sampler, and provides an iterable over
the given dataset.
The :class:`~torch.utils.data.DataLoader` supports both map-style and
iterable-style datasets with single- or multi-process loading, customizing
loading order and optional automatic batching (collation) and memory pinning.
See :py:mod:`torch.utils.data` documentation page for more details.
Arguments:
dataset (Dataset): dataset from which to load the data.
batch_size (int, optional): how many samples per batch to load
(default: ``1``).
shuffle (bool, optional): set to ``True`` to have the data reshuffled
at every epoch (default: ``False``).
sampler (Sampler, optional): defines the strategy to draw samples from
the dataset. If specified, :attr:`shuffle` must be ``False``.
batch_sampler (Sampler, optional): like :attr:`sampler`, but returns a batch of
indices at a time. Mutually exclusive with :attr:`batch_size`,
:attr:`shuffle`, :attr:`sampler`, and :attr:`drop_last`.
num_workers (int, optional): how many subprocesses to use for data
loading. ``0`` means that the data will be loaded in the main process.
(default: ``0``)
collate_fn (callable, optional): merges a list of samples to form a
mini-batch of Tensor(s). Used when using batched loading from a
map-style dataset.
pin_memory (bool, optional): If ``True``, the data loader will copy Tensors
into CUDA pinned memory before returning them. If your data elements
are a custom type, or your :attr:`collate_fn` returns a batch that is a custom type,
see the example below.
drop_last (bool, optional): set to ``True`` to drop the last incomplete batch,
if the dataset size is not divisible by the batch size. If ``False`` and
the size of dataset is not divisible by the batch size, then the last batch
will be smaller. (default: ``False``)
timeout (numeric, optional): if positive, the timeout value for collecting a batch
from workers. Should always be non-negative. (default: ``0``)
worker_init_fn (callable, optional): If not ``None``, this will be called on each
worker subprocess with the worker id (an int in ``[0, num_workers - 1]``) as
input, after seeding and before data loading. (default: ``None``)
.. warning:: If the ``spawn`` start method is used, :attr:`worker_init_fn`
cannot be an unpicklable object, e.g., a lambda function. See
:ref:`multiprocessing-best-practices` on more details related
to multiprocessing in PyTorch.
.. note:: ``len(dataloader)`` heuristic is based on the length of the sampler used.
When :attr:`dataset` is an :class:`~torch.utils.data.IterableDataset`,
an infinite sampler is used, whose :meth:`__len__` is not
implemented, because the actual length depends on both the
iterable as well as multi-process loading configurations. So one
should not query this method unless they work with a map-style
dataset. See `Dataset Types`_ for more details on these two types
of datasets.
"""
__initialized = False
def __init__(self, dataset, batch_size=1, shuffle=False, sampler=None,
batch_sampler=None, num_workers=0, collate_fn=None,
pin_memory=False, drop_last=False, timeout=0,
worker_init_fn=None, multiprocessing_context=None):
torch._C._log_api_usage_once("python.data_loader")
if num_workers < 0:
raise ValueError('num_workers option should be non-negative; '
'use num_workers=0 to disable multiprocessing.')
if timeout < 0:
raise ValueError('timeout option should be non-negative')
self.dataset = dataset
self.num_workers = num_workers
self.pin_memory = pin_memory
self.timeout = timeout
self.worker_init_fn = worker_init_fn
self.multiprocessing_context = multiprocessing_context
# Arg-check dataset related before checking samplers because we want to
# tell users that iterable-style datasets are incompatible with custom
# samplers first, so that they don't learn that this combo doesn't work
# after spending time fixing the custom sampler errors.
if isinstance(dataset, IterableDataset):
self._dataset_kind = _DatasetKind.Iterable
# NOTE [ Custom Samplers and `IterableDataset` ]
#
# `IterableDataset` does not support custom `batch_sampler` or
# `sampler` since the key is irrelevant (unless we support
# generator-style dataset one day...).
#
# For `sampler`, we always create a dummy sampler. This is an
# infinite sampler even when the dataset may have an implemented
# finite `__len__` because in multi-process data loading, naive
# settings will return duplicated data (which may be desired), and
# thus using a sampler with length matching that of dataset will
# cause data lost (you may have duplicates of the first couple
# batches, but never see anything afterwards). Therefore,
# `Iterabledataset` always uses an infinite sampler, an instance of
# `_InfiniteConstantSampler` defined above.
#
# A custom `batch_sampler` essentially only controls the batch size.
# However, it is unclear how useful it would be since an iterable-style
# dataset can handle that within itself. Moreover, it is pointless
# in multi-process data loading as the assignment order of batches
# to workers is an implementation detail so users can not control
# how to batchify each worker's iterable. Thus, we disable this
# option. If this turns out to be useful in future, we can re-enable
# this, and support custom samplers that specify the assignments to
# specific workers.
if shuffle is not False:
raise ValueError(
"DataLoader with IterableDataset: expected unspecified "
"shuffle option, but got shuffle={}".format(shuffle))
elif sampler is not None:
# See NOTE [ Custom Samplers and IterableDataset ]
raise ValueError(
"DataLoader with IterableDataset: expected unspecified "
"sampler option, but got sampler={}".format(sampler))
elif batch_sampler is not None:
# See NOTE [ Custom Samplers and IterableDataset ]
raise ValueError(
"DataLoader with IterableDataset: expected unspecified "
"batch_sampler option, but got batch_sampler={}".format(batch_sampler))
else:
self._dataset_kind = _DatasetKind.Map
if sampler is not None and shuffle:
raise ValueError('sampler option is mutually exclusive with '
'shuffle')
if batch_sampler is not None:
# auto_collation with custom batch_sampler
if batch_size != 1 or shuffle or sampler is not None or drop_last:
raise ValueError('batch_sampler option is mutually exclusive '
'with batch_size, shuffle, sampler, and '
'drop_last')
batch_size = None
drop_last = False
elif batch_size is None:
# no auto_collation
if shuffle or drop_last:
raise ValueError('batch_size=None option disables auto-batching '
'and is mutually exclusive with '
'shuffle, and drop_last')
if sampler is None: # give default samplers
if self._dataset_kind == _DatasetKind.Iterable:
# See NOTE [ Custom Samplers and IterableDataset ]
sampler = _InfiniteConstantSampler()
else: # map-style
if shuffle:
sampler = RandomSampler(dataset)
else:
sampler = SequentialSampler(dataset)
if batch_size is not None and batch_sampler is None:
# auto_collation without custom batch_sampler
batch_sampler = BatchSampler(sampler, batch_size, drop_last)
self.batch_size = batch_size
self.drop_last = drop_last
self.sampler = sampler
self.batch_sampler = batch_sampler
if collate_fn is None:
if self._auto_collation:
collate_fn = _utils.collate.default_collate
else:
collate_fn = _utils.collate.default_convert
self.collate_fn = collate_fn
self.__initialized = True
@property
def multiprocessing_context(self):
return self.__multiprocessing_context
@multiprocessing_context.setter
def multiprocessing_context(self, multiprocessing_context):
if multiprocessing_context is not None:
if self.num_workers > 0:
if not multiprocessing._supports_context:
raise ValueError('multiprocessing_context relies on Python >= 3.4, with '
'support for different start methods')
if isinstance(multiprocessing_context, string_classes):
valid_start_methods = multiprocessing.get_all_start_methods()
if multiprocessing_context not in valid_start_methods:
raise ValueError(
('multiprocessing_context option '
'should specify a valid start method in {}, but got '
'multiprocessing_context={}').format(valid_start_methods, multiprocessing_context))
multiprocessing_context = multiprocessing.get_context(multiprocessing_context)
if not isinstance(multiprocessing_context, python_multiprocessing.context.BaseContext):
raise ValueError(('multiprocessing_context option should be a valid context '
'object or a string specifying the start method, but got '
'multiprocessing_context={}').format(multiprocessing_context))
else:
raise ValueError(('multiprocessing_context can only be used with '
'multi-process loading (num_workers > 0), but got '
'num_workers={}').format(self.num_workers))
self.__multiprocessing_context = multiprocessing_context
def __setattr__(self, attr, val):
if self.__initialized and attr in ('batch_size', 'batch_sampler', 'sampler', 'drop_last', 'dataset'):
raise ValueError('{} attribute should not be set after {} is '
'initialized'.format(attr, self.__class__.__name__))
super(DataLoader, self).__setattr__(attr, val)
def __iter__(self):
if self.num_workers == 0:
return _SingleProcessDataLoaderIter(self)
else:
return _MultiProcessingDataLoaderIter(self)
@property
def _auto_collation(self):
return self.batch_sampler is not None
@property
def _index_sampler(self):
# The actual sampler used for generating indices for `_DatasetFetcher`
# (see _utils/fetch.py) to read data at each time. This would be
# `.batch_sampler` if in auto-collation mode, and `.sampler` otherwise.
# We can't change `.sampler` and `.batch_sampler` attributes for BC
# reasons.
if self._auto_collation:
return self.batch_sampler
else:
return self.sampler
def __len__(self):
return len(self._index_sampler) # with iterable-style dataset, this will error
class _BaseDataLoaderIter(object):
def __init__(self, loader):
self._dataset = loader.dataset
self._dataset_kind = loader._dataset_kind
self._auto_collation = loader._auto_collation
self._drop_last = loader.drop_last
self._index_sampler = loader._index_sampler
self._num_workers = loader.num_workers
self._pin_memory = loader.pin_memory and torch.cuda.is_available()
self._timeout = loader.timeout
self._collate_fn = loader.collate_fn
self._sampler_iter = iter(self._index_sampler)
self._base_seed = torch.empty((), dtype=torch.int64).random_().item()
def __iter__(self):
return self
def _next_index(self):
return next(self._sampler_iter) # may raise StopIteration
def __next__(self):
raise NotImplementedError
def __len__(self):
return len(self._index_sampler)
def __getstate__(self):
# TODO: add limited pickling support for sharing an iterator
# across multiple threads for HOGWILD.
# Probably the best way to do this is by moving the sample pushing
# to a separate thread and then just sharing the data queue
# but signalling the end is tricky without a non-blocking API
raise NotImplementedError("{} cannot be pickled", self.__class__.__name__)
class _SingleProcessDataLoaderIter(_BaseDataLoaderIter):
def __init__(self, loader):
super(_SingleProcessDataLoaderIter, self).__init__(loader)
assert self._timeout == 0
assert self._num_workers == 0
self._dataset_fetcher = _DatasetKind.create_fetcher(
self._dataset_kind, self._dataset, self._auto_collation, self._collate_fn, self._drop_last)
def __next__(self):
index = self._next_index() # may raise StopIteration
data = self._dataset_fetcher.fetch(index) # may raise StopIteration
if self._pin_memory:
data = _utils.pin_memory.pin_memory(data)
return data
next = __next__ # Python 2 compatibility
class _MultiProcessingDataLoaderIter(_BaseDataLoaderIter):
r"""Iterates once over the DataLoader's dataset, as specified by the sampler"""
# NOTE [ Data Loader Multiprocessing Shutdown Logic ]
#
# Preliminary:
#
# Our data model looks like this (queues are indicated with curly brackets):
#
# main process ||
# | ||
# {index_queue} ||
# | ||
# worker processes || DATA
# | ||
# {worker_result_queue} || FLOW
# | ||
# pin_memory_thread of main process || DIRECTION
# | ||
# {data_queue} ||
# | ||
# data output \/
#
# P.S. `worker_result_queue` and `pin_memory_thread` part may be omitted if
# `pin_memory=False`.
#
#
# Terminating multiprocessing logic requires very careful design. In
# particular, we need to make sure that
#
# 1. The iterator gracefully exits the workers when its last reference is
# gone or it is depleted.
#
# In this case, the workers should be gracefully exited because the
# main process may still need to continue to run, and we want cleaning
# up code in the workers to be executed (e.g., releasing GPU memory).
# Naturally, we implement the shutdown logic in `__del__` of
# DataLoaderIterator.
#
# We delay the discussion on the logic in this case until later.
#
# 2. The iterator exits the workers when the loader process and/or worker
# processes exits normally or with error.
#
# We set all workers and `pin_memory_thread` to have `daemon=True`.
#
# You may ask, why can't we make the workers non-daemonic, and
# gracefully exit using the same logic as we have in `__del__` when the
# iterator gets deleted (see 1 above)?
#
# First of all, `__del__` is **not** guaranteed to be called when
# interpreter exits. Even if it is called, by the time it executes,
# many Python core library resources may alreay be freed, and even
# simple things like acquiring an internal lock of a queue may hang.
# Therefore, in this case, we actually need to prevent `__del__` from
# being executed, and rely on the automatic termination of daemonic
# children. Thus, we register an `atexit` hook that sets a global flag
# `_utils.python_exit_status`. Since `atexit` hooks are executed in the
# reverse order of registration, we are guaranteed that this flag is
# set before library resources we use are freed. (Hooks freeing those
# resources are registered at importing the Python core libraries at
# the top of this file.) So in `__del__`, we check if
# `_utils.python_exit_status` is set or `None` (freed), and perform
# no-op if so.
#
# Another problem with `__del__` is also related to the library cleanup
# calls. When a process ends, it shuts the all its daemonic children
# down with a SIGTERM (instead of joining them without a timeout).
# Simiarly for threads, but by a different mechanism. This fact,
# together with a few implementation details of multiprocessing, forces
# us to make workers daemonic. All of our problems arise when a
# DataLoader is used in a subprocess, and are caused by multiprocessing
# code which looks more or less like this:
#
# try:
# your_function_using_a_dataloader()
# finally:
# multiprocessing.util._exit_function()
#
# The joining/termination mentioned above happens inside
# `_exit_function()`. Now, if `your_function_using_a_dataloader()`
# throws, the stack trace stored in the exception will prevent the
# frame which uses `DataLoaderIter` to be freed. If the frame has any
# reference to the `DataLoaderIter` (e.g., in a method of the iter),
# its `__del__`, which starts the shutdown procedure, will not be
# called. That, in turn, means that workers aren't notified. Attempting
# to join in `_exit_function` will then result in a hang.
#
# For context, `_exit_function` is also registered as an `atexit` call.
# So it is unclear to me (@ssnl) why this is needed in a finally block.
# The code dates back to 2008 and there is no comment on the original
# PEP 371 or patch https://bugs.python.org/issue3050 (containing both
# the finally block and the `atexit` registration) that explains this.
#
# Another choice is to just shutdown workers with logic in 1 above
# whenever we see an error in `next`. This isn't ideal because
# a. It prevents users from using try-catch to resume data loading.
# b. It doesn't prevent hanging if users have references to the
# iterator.
#
# 3. All processes exit if any of them die unexpectedly by fatal signals.
#
# As shown above, the workers are set as daemonic children of the main
# process. However, automatic cleaning-up of such child processes only
# happens if the parent process exits gracefully (e.g., not via fatal
# signals like SIGKILL). So we must ensure that each process will exit
# even the process that should send/receive data to/from it were
# killed, i.e.,
#
# a. A process won't hang when getting from a queue.
#
# Even with carefully designed data dependencies (i.e., a `put()`
# always corresponding to a `get()`), hanging on `get()` can still
# happen when data in queue is corrupted (e.g., due to
# `cancel_join_thread` or unexpected exit).
#
# For child exit, we set a timeout whenever we try to get data
# from `data_queue`, and check the workers' status on each timeout
# and error.
# See `_DataLoaderiter._get_batch()` and
# `_DataLoaderiter._try_get_data()` for details.
#
# Additionally, for child exit on non-Windows platforms, we also
# register a SIGCHLD handler (which is supported on Windows) on
# the main process, which checks if any of the workers fail in the
# (Python) handler. This is more efficient and faster in detecting
# worker failures, compared to only using the above mechanism.
# See `DataLoader.cpp` and `_utils/signal_handling.py` for details.
#
# For `.get()` calls where the sender(s) is not the workers, we
# guard them with timeouts, and check the status of the sender
# when timeout happens:
# + in the workers, the `_utils.worker.ManagerWatchdog` class
# checks the status of the main process.
# + if `pin_memory=True`, when getting from `pin_memory_thread`,
# check `pin_memory_thread` status periodically until `.get()`
# returns or see that `pin_memory_thread` died.
#
# b. A process won't hang when putting into a queue;
#
# We use `mp.Queue` which has a separate background thread to put
# objects from an unbounded buffer array. The background thread is
# daemonic and usually automatically joined when the process
# exits.
#
# However, in case that the receiver has ended abruptly while
# reading from the pipe, the join will hang forever. Therefore,
# for both `worker_result_queue` (worker -> main process/pin_memory_thread)
# and each `index_queue` (main process -> worker), we use
# `q.cancel_join_thread()` in sender process before any `q.put` to
# prevent this automatic join.
#
# Moreover, having all queues called `cancel_join_thread` makes
# implementing graceful shutdown logic in `__del__` much easier.
# It won't need to get from any queue, which would also need to be
# guarded by periodic status checks.
#
# Nonetheless, `cancel_join_thread` must only be called when the
# queue is **not** going to be read from or write into by another
# process, because it may hold onto a lock or leave corrupted data
# in the queue, leading other readers/writers to hang.
#
# `pin_memory_thread`'s `data_queue` is a `queue.Queue` that does
# a blocking `put` if the queue is full. So there is no above
# problem, but we do need to wrap the `put` in a loop that breaks
# not only upon success, but also when the main process stops
# reading, i.e., is shutting down.
#
#
# Now let's get back to 1:
# how we gracefully exit the workers when the last reference to the
# iterator is gone.
#
# To achieve this, we implement the following logic along with the design
# choices mentioned above:
#
# `workers_done_event`:
# A `multiprocessing.Event` shared among the main process and all worker
# processes. This is used to signal the workers that the iterator is
# shutting down. After it is set, they will not send processed data to
# queues anymore, and only wait for the final `None` before exiting.
# `done_event` isn't strictly needed. I.e., we can just check for `None`
# from the input queue, but it allows us to skip wasting resources
# processing data if we are already shutting down.
#
# `pin_memory_thread_done_event`:
# A `threading.Event` for a similar purpose to that of
# `workers_done_event`, but is for the `pin_memory_thread`. The reason
# that separate events are needed is that `pin_memory_thread` reads from
# the output queue of the workers. But the workers, upon seeing that
# `workers_done_event` is set, only wants to see the final `None`, and is
# not required to flush all data in the output queue (e.g., it may call
# `cancel_join_thread` on that queue if its `IterableDataset` iterator
# happens to exhaust coincidentally, which is out of the control of the
# main process). Thus, since we will exit `pin_memory_thread` before the
# workers (see below), two separete events are used.
#
# NOTE: In short, the protocol is that the main process will set these
# `done_event`s and then the corresponding processes/threads a `None`,
# and that they may exit at any time after receiving the `None`.
#
# NOTE: Using `None` as the final signal is valid, since normal data will
# always be a 2-tuple with the 1st element being the index of the data
# transferred (different from dataset index/key), and the 2nd being
# either the dataset key or the data sample (depending on which part
# of the data model the queue is at).
#
# [ worker processes ]
# While loader process is alive:
# Get from `index_queue`.
# If get anything else,
# Check `workers_done_event`.
# If set, continue to next iteration
# i.e., keep getting until see the `None`, then exit.
# Otherwise, process data:
# If is fetching from an `IterableDataset` and the iterator
# is exhausted, send an `_IterableDatasetStopIteration`
# object to signal iteration end. The main process, upon
# receiving such an object, will send `None` to this
# worker and not use the corresponding `index_queue`
# anymore.
# If timed out,
# No matter `workers_done_event` is set (still need to see `None`)
# or not, must continue to next iteration.
# (outside loop)
# If `workers_done_event` is set, (this can be False with `IterableDataset`)
# `data_queue.cancel_join_thread()`. (Everything is ending here:
# main process won't read from it;
# other workers will also call
# `cancel_join_thread`.)
#
# [ pin_memory_thread ]
# # No need to check main thread. If this thread is alive, the main loader
# # thread must be alive, because this thread is set as daemonic.
# While `pin_memory_thread_done_event` is not set:
# Get from `index_queue`.
# If timed out, continue to get in the next iteration.
# Otherwise, process data.
# While `pin_memory_thread_done_event` is not set:
# Put processed data to `data_queue` (a `queue.Queue` with blocking put)
# If timed out, continue to put in the next iteration.
# Otherwise, break, i.e., continuing to the out loop.
#
# NOTE: we don't check the status of the main thread because
# 1. if the process is killed by fatal signal, `pin_memory_thread`
# ends.
# 2. in other cases, either the cleaning-up in __del__ or the
# automatic exit of daemonic thread will take care of it.
# This won't busy-wait either because `.get(timeout)` does not
# busy-wait.
#
# [ main process ]
# In the DataLoader Iter's `__del__`
# b. Exit `pin_memory_thread`
# i. Set `pin_memory_thread_done_event`.
# ii Put `None` in `worker_result_queue`.
# iii. Join the `pin_memory_thread`.
# iv. `worker_result_queue.cancel_join_thread()`.
#
# c. Exit the workers.
# i. Set `workers_done_event`.
# ii. Put `None` in each worker's `index_queue`.
# iii. Join the workers.
# iv. Call `.cancel_join_thread()` on each worker's `index_queue`.
#
# NOTE: (c) is better placed after (b) because it may leave corrupted
# data in `worker_result_queue`, which `pin_memory_thread`
# reads from, in which case the `pin_memory_thread` can only
# happen at timeing out, which is slow. Nonetheless, same thing
# happens if a worker is killed by signal at unfortunate times,
# but in other cases, we are better off having a non-corrupted
# `worker_result_queue` for `pin_memory_thread`.
#
# NOTE: If `pin_memory=False`, there is no `pin_memory_thread` and (b)
# can be omitted
#
# NB: `done_event`s isn't strictly needed. E.g., we can just check for
# `None` from `index_queue`, but it allows us to skip wasting resources
# processing indices already in `index_queue` if we are already shutting
# down.
def __init__(self, loader):
super(_MultiProcessingDataLoaderIter, self).__init__(loader)
assert self._num_workers > 0
if loader.multiprocessing_context is None:
multiprocessing_context = multiprocessing
else:
multiprocessing_context = loader.multiprocessing_context
self._worker_init_fn = loader.worker_init_fn
self._worker_queue_idx_cycle = itertools.cycle(range(self._num_workers))
self._worker_result_queue = multiprocessing_context.Queue()
self._worker_pids_set = False
self._shutdown = False
self._send_idx = 0 # idx of the next task to be sent to workers
self._rcvd_idx = 0 # idx of the next task to be returned in __next__
# information about data not yet yielded, i.e., tasks w/ indices in range [rcvd_idx, send_idx).
# map: task idx => - (worker_id,) if data isn't fetched (outstanding)
# \ (worker_id, data) if data is already fetched (out-of-order)
self._task_info = {}
self._tasks_outstanding = 0 # always equal to count(v for v in task_info.values() if len(v) == 1)
self._workers_done_event = multiprocessing_context.Event()
self._index_queues = []
self._workers = []
# A list of booleans representing whether each worker still has work to
# do, i.e., not having exhausted its iterable dataset object. It always
# contains all `True`s if not using an iterable-style dataset
# (i.e., if kind != Iterable).
self._workers_status = []
for i in range(self._num_workers):
index_queue = multiprocessing_context.Queue()
# index_queue.cancel_join_thread()
w = multiprocessing_context.Process(
target=_utils.worker._worker_loop,
args=(self._dataset_kind, self._dataset, index_queue,
self._worker_result_queue, self._workers_done_event,
self._auto_collation, self._collate_fn, self._drop_last,
self._base_seed + i, self._worker_init_fn, i, self._num_workers))
w.daemon = True
# NB: Process.start() actually take some time as it needs to
# start a process and pass the arguments over via a pipe.
# Therefore, we only add a worker to self._workers list after
# it started, so that we do not call .join() if program dies
# before it starts, and __del__ tries to join but will get:
# AssertionError: can only join a started process.
w.start()
self._index_queues.append(index_queue)
self._workers.append(w)
self._workers_status.append(True)
if self._pin_memory:
self._pin_memory_thread_done_event = threading.Event()
self._data_queue = queue.Queue()
pin_memory_thread = threading.Thread(
target=_utils.pin_memory._pin_memory_loop,
args=(self._worker_result_queue, self._data_queue,
torch.cuda.current_device(),
self._pin_memory_thread_done_event))
pin_memory_thread.daemon = True
pin_memory_thread.start()
# Similar to workers (see comment above), we only register
# pin_memory_thread once it is started.
self._pin_memory_thread = pin_memory_thread
else:
self._data_queue = self._worker_result_queue
_utils.signal_handling._set_worker_pids(id(self), tuple(w.pid for w in self._workers))
_utils.signal_handling._set_SIGCHLD_handler()
self._worker_pids_set = True
# prime the prefetch loop
for _ in range(2 * self._num_workers):
self._try_put_index()
def _try_get_data(self, timeout=_utils.MP_STATUS_CHECK_INTERVAL):
# Tries to fetch data from `self._data_queue` once for a given timeout.
# This can also be used as inner loop of fetching without timeout, with
# the sender status as the loop condition.
#
# This raises a `RuntimeError` if any worker died expectedly. This error
# can come from either the SIGCHLD handler in `_utils/signal_handling.py`
# (only for non-Windows platforms), or the manual check below on errors
# and timeouts.
#
# Returns a 2-tuple:
# (bool: whether successfully get data, any: data if successful else None)
try:
data = self._data_queue.get(timeout=timeout)
return (True, data)
except Exception as e:
# At timeout and error, we manually check whether any worker has
# failed. Note that this is the only mechanism for Windows to detect
# worker failures.
failed_workers = []
for worker_id, w in enumerate(self._workers):
if self._workers_status[worker_id] and not w.is_alive():
failed_workers.append(w)
self._shutdown_worker(worker_id)
if len(failed_workers) > 0:
pids_str = ', '.join(str(w.pid) for w in failed_workers)
raise RuntimeError('DataLoader worker (pid(s) {}) exited unexpectedly'.format(pids_str))
if isinstance(e, queue.Empty):
return (False, None)
raise
def _get_data(self):
# Fetches data from `self._data_queue`.
#
# We check workers' status every `MP_STATUS_CHECK_INTERVAL` seconds,
# which we achieve by running `self._try_get_data(timeout=MP_STATUS_CHECK_INTERVAL)`
# in a loop. This is the only mechanism to detect worker failures for
# Windows. For other platforms, a SIGCHLD handler is also used for
# worker failure detection.
#
# If `pin_memory=True`, we also need check if `pin_memory_thread` had
# died at timeouts.
if self._timeout > 0:
success, data = self._try_get_data(self._timeout)
if success:
return data
else:
raise RuntimeError('DataLoader timed out after {} seconds'.format(self._timeout))
elif self._pin_memory:
while self._pin_memory_thread.is_alive():
success, data = self._try_get_data()
if success:
return data
else:
# while condition is false, i.e., pin_memory_thread died.
raise RuntimeError('Pin memory thread exited unexpectedly')
# In this case, `self._data_queue` is a `queue.Queue`,. But we don't
# need to call `.task_done()` because we don't use `.join()`.
else:
while True:
success, data = self._try_get_data()
if success:
return data
def __next__(self):
while True:
# If the worker responsible for `self._rcvd_idx` has already ended
# and was unable to fulfill this task (due to exhausting an `IterableDataset`),
# we try to advance `self._rcvd_idx` to find the next valid index.
#
# This part needs to run in the loop because both the `self._get_data()`
# call and `_IterableDatasetStopIteration` check below can mark
# extra worker(s) as dead.
while self._rcvd_idx < self._send_idx:
info = self._task_info[self._rcvd_idx]
worker_id = info[0]
if len(info) == 2 or self._workers_status[worker_id]: # has data or is still active
break
del self._task_info[self._rcvd_idx]
self._rcvd_idx += 1
else:
# no valid `self._rcvd_idx` is found (i.e., didn't break)
self._shutdown_workers()
raise StopIteration
# Now `self._rcvd_idx` is the batch index we want to fetch
# Check if the next sample has already been generated
if len(self._task_info[self._rcvd_idx]) == 2:
data = self._task_info.pop(self._rcvd_idx)[1]
return self._process_data(data)
assert not self._shutdown and self._tasks_outstanding > 0
idx, data = self._get_data()
self._tasks_outstanding -= 1
if self._dataset_kind == _DatasetKind.Iterable:
# Check for _IterableDatasetStopIteration
if isinstance(data, _utils.worker._IterableDatasetStopIteration):
self._shutdown_worker(data.worker_id)
self._try_put_index()
continue
if idx != self._rcvd_idx:
# store out-of-order samples
self._task_info[idx] += (data,)
else:
del self._task_info[idx]
return self._process_data(data)
next = __next__ # Python 2 compatibility
def _try_put_index(self):
assert self._tasks_outstanding < 2 * self._num_workers
try:
index = self._next_index()
except StopIteration:
return
for _ in range(self._num_workers): # find the next active worker, if any
worker_queue_idx = next(self._worker_queue_idx_cycle)
if self._workers_status[worker_queue_idx]:
break
else:
# not found (i.e., didn't break)
return
self._index_queues[worker_queue_idx].put((self._send_idx, index))
self._task_info[self._send_idx] = (worker_queue_idx,)
self._tasks_outstanding += 1
self._send_idx += 1
def _process_data(self, data):
self._rcvd_idx += 1
self._try_put_index()
if isinstance(data, ExceptionWrapper):
data.reraise()
return data
def _shutdown_worker(self, worker_id):
# Mark a worker as having finished its work and dead, e.g., due to
# exhausting an `IterableDataset`. This should be used only when this
# `_MultiProcessingDataLoaderIter` is going to continue running.
assert self._workers_status[worker_id]
# Signal termination to that specific worker.
q = self._index_queues[worker_id]
# Indicate that no more data will be put on this queue by the current
# process.
q.put(None)
# Note that we don't actually join the worker here, nor do we remove the
# worker's pid from C side struct because (1) joining may be slow, and
# (2) since we don't join, the worker may still raise error, and we
# prefer capturing those, rather than ignoring them, even though they
# are raised after the worker has finished its job.
# Joinning is deferred to `_shutdown_workers`, which it is called when
# all workers finish their jobs (e.g., `IterableDataset` replicas) or
# when this iterator is garbage collected.
self._workers_status[worker_id] = False
def _shutdown_workers(self):
# Called when shutting down this `_MultiProcessingDataLoaderIter`.
# See NOTE [ Data Loader Multiprocessing Shutdown Logic ] for details on
# the logic of this function.
python_exit_status = _utils.python_exit_status
if python_exit_status is True or python_exit_status is None:
# See (2) of the note. If Python is shutting down, do no-op.
return
# Normal exit when last reference is gone / iterator is depleted.
# See (1) and the second half of the note.
if not self._shutdown:
self._shutdown = True
try:
# Exit `pin_memory_thread` first because exiting workers may leave
# corrupted data in `worker_result_queue` which `pin_memory_thread`
# reads from.
if hasattr(self, '_pin_memory_thread'):
# Use hasattr in case error happens before we set the attribute.
self._pin_memory_thread_done_event.set()
# Send something to pin_memory_thread in case it is waiting
# so that it can wake up and check `pin_memory_thread_done_event`
self._worker_result_queue.put((None, None))
self._pin_memory_thread.join()
self._worker_result_queue.close()
# Exit workers now.
self._workers_done_event.set()
for worker_id in range(len(self._workers)):
# Get number of workers from `len(self._workers)` instead of
# `self._num_workers` in case we error before starting all
# workers.
if self._workers_status[worker_id]:
self._shutdown_worker(worker_id)
for w in self._workers:
w.join()
for q in self._index_queues:
q.cancel_join_thread()
q.close()
finally:
# Even though all this function does is putting into queues that
# we have called `cancel_join_thread` on, weird things can
# happen when a worker is killed by a signal, e.g., hanging in
# `Event.set()`. So we need to guard this with SIGCHLD handler,
# and remove pids from the C side data structure only at the
# end.
#
# FIXME: Unfortunately, for Windows, we are missing a worker
# error detection mechanism here in this function, as it
# doesn't provide a SIGCHLD handler.
if self._worker_pids_set:
_utils.signal_handling._remove_worker_pids(id(self))
self._worker_pids_set = False
def __del__(self):
self._shutdown_workers()


The purpose of this software is to help students achieve mastery of a wide variety of topics in physics, mathematics and engineering (STEM) through the authentic construction of executable (software) models.
Thank You for considering GeometryZen to make your courses and assignments more engaging and effective!
I strongly encourage you to explore TypeScript (JavaScript with optional typing) as the programming language when looking for a friendly editing experience with type-checking, context-sensitive help and code-completion.
The immediate roadmap consists of providing more curated examples, better documentation support, and exploiting GitHub Gists as the basis for assignments.
I hope you will become part of the GeometryZen community!
- David Holmes


coolHue - Color Swatch and Palette
Coolest handpicked Gradient Hues for your next super
⚡
amazing stuff
Crafted with
❤
by
UVdesk
App
Sketch Palette
Photoshop Palette
Customize Palette
We are sorry but we can't help it, unless your browser supports Javascript.


Creates the next random, likely or systematic new(!) conformer of the molecule
that was passed when calling initializeConformers()
. A new conformer is one,
whose combination of torsion angles was not used in a previous conformer
created by this function since the last call of initializeConformers()
.
Parameter mol may be null or recycle the original molecule to receive new 3D coordinates.
If it is null, then a fresh copy of the original molecule with new atom coordinates is returned.
Every call of this method creates a new collision-free conformer until the employed torsion set
strategy decides that it cannot generate any more suitable torsion sets.
Fills all free valences of mol with explicit hydrogens and tries to create a reasonable conformer by starting with the most likely torsion set. If there are collisions, then less likely torsions are tried to find a collision free conformer. If it succeeds, mol receives the modified atom coordinates and mol is returned. If the conformer generation fails, then null is returned. The torsion strategy used is STRATEGY_ADAPTIVE_RANDOM. New 3D-coordinates correctly reflect E/Z and R/S bond/atom parities. This is a convenience method that does not require any initialization.
The molecule that will receive new 3D coordinates in place.
Calculates the potential count of conformers by multiplying degrees of freedom
(torsions per rotatable bond & rigid fragment multiplicities).
Cannot be called before calling initializeConformers()
.
With best current knowledge about colliding torsion combinations and based on the individual frequencies of currently active torsions this method returns the conformers's overall contribution to the total set of non colliding conformers.
The initializeConformers()
method needs to be called before getting individual
conformers of the same molecule by getNextConformerAsMolecule()
.
Open valences of the passed molecule are filled with hydrogen atoms.
The passed molecule may repeatedly be used as container for a new conformer's atom
coordinates, if it is passed to getNextConformerAsMolecule().
Will be saturated with hydrogen atoms.
false
if there is a structure problem.Returns an iterator of molecule conformers.


American Society of Civil Engineers
Bringing the global civil engineering community together.
We Represent:
- {{ ./tpl/x-stat.tpl.html }}
Promotions
Portals
- {{ ./tpl/x-portal.tpl.html }}
ASCE Foundation
{{ caption }}
Your Foundation!
Your Future!
You can make a difference!
Publication Highlights
- {{ ./tpl/x-pub.tpl.html }}
Learn & Contribute
- {{ ./tpl/x-homeaction.tpl.html }}
Jobs
- {{ ./tpl/x-job.tpl.html }}
ASCE News
- {{ ./tpl/x-article.tpl.html }}
ASCE Member Stories
- {{ ./tpl/x-member.tpl.html }}


In the past years you may have heard about "global warming" and "climate change" which are two different concepts but are extremely related.
Global WarmingGlobal warming refers to the upward temperature trend across the entire Earth since the early 20th century, and most notably since the late 1970s, due to the increase in fossil fuel emissions since the industrial revolution. Worldwide since 1880, the average surface temperature has gone up by about 0.8 °C (1.4 °F), relative to the mid-20th-century baseline (of 1951-1980). (NASA)
Climate ChangeClimate change refers to a broad range of global phenomena created predominantly by burning fossil fuels, which add heat-trapping gases to Earth’s atmosphere. These phenomena include the increased temperature trends described by global warming, but also encompass changes such as sea level rise; ice mass loss in Greenland, Antarctica, the Arctic and mountain glaciers worldwide; shifts in flower/plant blooming; and extreme weather events. (NASA)
The followng links provide more information about Climate Change and Global Warming presented by NASA.
warningHover your mouse over the dots in the graphics to see more information, click on them to filter.
Global mean temperature from january 1880 to august 2018.
infoSeasons are separated by quarters so: DJF is winter, MAM is spring, JJA is summer and SON is fall.
Global mean seasonal temperature from january 1880 to august 2018.
Dataset Type: Table
Items: Global Means
Attributes:
Global Mean Temperature Anomalies 1880-2018 uses:
Seasonal Mean Temperature Anomalies uses:
Although it's obvious that the global temperature is raising, with the first graphic there seems to be a periodic interval cycle of about 4-6 years between the peaks in the anomalies.
The temperature raising could be related to the beginning of experimentation with fossile combustibles that started by 1920 and began its mass use by 1950 approximately.
There is a rising peak during the first world war between 1914-1918 and the first significant temperature rising is between 1936-1945 that could be related to second world war that lasted between 1939-1945.
The season with the more variation in temperature is winter, in general there are years that have the most colder and the most warmer winter. Most colder season is winter 1917 and the warmer season is winter 2016.


Apparel for responsive-building, media-querying web citizens.
You Decide
Size us up and vote WTH? Show me the shirts
A short description of the shirt would go here and be very clever, witty, etc. As I said before, a short descriptor of the shirt would go here.
See Details105 votes
Dress Responsively, LTD. Doesn't exist. Yet.
This website is a product of Sparkbox’s Build Responsively workshop. Dress Responsively was built as a mock project to create working files and content for the workshop’s attendees. But then we got to thinking.
What standards-loving, responsively-building, media-querying web citizens wouldn’t love some apparel which flies the flag of the future of the web? Let’s turn it over to the people.
So here we are. If we are able to stump for enough interest, tweets, and votes for this geek wear, we’ll print up the winner and make it available. Check out the shirt designs, vote for your frontrunner, and pass us along to your friends. Democracy at work, folks. It’s either that or mob rule, whichever comes first. Either way, we all get sweet shirts out of it.
Got a question or a comment? Send us the emails.


Protesters spill back onto bridge in Iraq capital
BAGHDAD: Anti-government demonstrators spread to a second bridge in the Iraqi capital on Saturday (Nov 16) after security forces retreated from a key area where they had clashed with protesters, AFP correspondents said.
Sit-ins have become the go-to tactic for the regime change movement that erupted in early October, with a general strike announced by activists for Sunday.
Protesters have occupied Baghdad's Tahrir (Liberation) Square since Oct 24, spilling over onto four bridges crossing the river Tigris.
The bridges link east Baghdad to the city's west, including the Green Zone where the prime minister's office, parliament and foreign embassies are based.
Security forces retook three of those bridges and nearby districts more than two weeks ago, pinning the protesters back in Tahrir and on Al-Jumhuriyah bridge with volleys of tear gas, live ammunition and even machine-gun fire.
On Saturday morning, Iraqi units pulled back from some of those areas and crowds of protesters chased them down, resuming their sit-in at the mouth of Al-Sinek bridge.
"The security forces withdrew to another concrete barrier on Al-Sinek," one protester told AFP.
An elderly woman, who had travelled from the southern port city of Basra to join the rallies, cheered in support.
"You didn't just lose us, you lost all of Iraq!" she said, addressing Prime Minister Adel Abdel Mahdi.
 Tonight, we'll be in the Green Zone," she said.
Dozens climbed up into a large parking complex near the bridge, unfurling a sign in support of demonstrators in nearby Tahrir.
Others set up checkpoints around Tahrir, the morning after a bomb blast that shook the protesters.
On Friday night, at least one person was killed and more than a dozen wounded in Tahrir when explosives beneath a parked car detonated, Iraq's state security forces said.
Small clusters of men deployed around the square to search all those entering it throughout the day on Saturday.
"We had a security breach yesterday and this explosion happened," said Abu Karrar al-Basrawi, a middle-aged man from Basra volunteering for the search.
"But we've multiplied our checkpoints so it doesn't happen again," he told AFP.
Activists and medics have described a climate of fear setting in around Tahrir, saying that anonymous threats, kidnappings and even killings are an attempt to snuff out the movement.
Late on Friday, activist Adnan Rustum was shot dead near his home in Baghdad, his relatives said.
And on Saturday, a person died of wounds sustained the previous day in protests in the southern city of Nasiriyah.
More than 330 people have been killed since the protests erupted in October and over 15,000 have been wounded, but officials are not releasing updated or precise figures.


Why are there garbage characters in the text fields?
Hextrapolate provides two adjustable fields for showing a number in a text encoding of your choice (ASCII, UTF-8 or UTF-16). It is normal for garbage characters to appear in these text fields, depending on the number under conversion.
For example, you might enter a number that corresponds to valid UTF-8 or UTF-16 but your system does not have a font installed that contains the corresponding glyphs. In these cases the system may substitute a meaningless character such as a square or a box.
It is also possible that the textual representation is valid and the corresponding glyphs are available but they are from a foreign alphabet.
The screenshot below demonstrates both of these possibilities.


Improve your front-end skills by building projects
Scan the QR code to visit Frontend Mentor and take your coding skills to the next level


Text to UML , freely .
Powered by :
PlantUml
,
Orion
,
Webix
. Version: ${project.version}-${timestamp} , fork at github. author:Alex.


Woman held captive, abused at Knoxville motel; man charged with kidnapping
KNOXVILLE, Tenn. (WVLT) - Knoxville Police said a man has been arrested after an alert bulletin out of Oak Ridge helped officers locate and arrest a man charged with holding a woman against her will at a Knoxville motel.
A little after 8:30 p.m. on Saturday, December 7th, Knoxville police officers received a bulletin from the Oak Ridge Police Department, stating that the man and woman were at a Motel 6 at an unknown location in or around Knoxville. The bulletin also stated that the subject would be driving a 2003 Ford Taurus.
Officers responded to the Motel 6 on Harry Lane Boulevard in west Knoxville and observed the suspect vehicle in the back parking lot. Officers identified and approached the room, knocked on the door and located both the suspect, 42-year-old Gregory Fujii, and the victim inside the room.
Officers took Fujii into custody and spoke with the female victim, who stated that she and Fujii had been dating for almost two years.
According to the victim, Fujii had been holding the victim in the room for hours and had assaulted her multiple times, including burning her with a cigarette and throwing her into a wall.
Fujii was charged with aggravated kidnapping and domestic assault. He is being held on a $75,000 bond.


{% extends "layout.html" %} {% block page_title %} Money Claims Prototype {% endblock %} {% block proposition_header %} {% include "includes/propositional_navigation.html" %} {% endblock %} {% block content %} {% include "includes/phase_banner_beta.html" %} Tell us why you decided to claim £1,500 You should mention evidence that you believe shows the value of the claim, for example repair quotes or receipts. Include exhibit numbers. Amount payable by defendant Amount breakdown Amount Cost of repairing the roof £1000 Buying the parts to repair the roof £430 Claim fee Claim fee £70 Claim total £1,500 See a list of your evidence Exhibit A1 Emails.pdf You can see the emails dated {{ date | date('subtract', 123, 'days') | date }} and {{ date | date('subtract', 134, 'days') | date }} that they claimed not to receive. Exhibit A2 Photo 1.jpg The photos show that the roof was not adequately supported. Exhibit A3 Photo 2.jpg Exhibit A4 Contract.pdf The signed contract shows the materials we agreed to use. Add another evidence file {% include 'prototypes/prototype-feb-2020/includes/contact.html' %} {% endblock %}
You should mention evidence that you believe shows the value of the claim, for example repair quotes or receipts. Include exhibit numbers.


|
PX4 Firmware
PX4 Autopilot Software http://px4.io
|
The GPS sensor message Struct based on: https://code.google.com/p/diy-hott-gps/downloads. More...
#include <messages.h>
Public Attributes | |
| uint8_t | start |
| Start byte. More... | |
| uint8_t | sensor_id |
| GPS sensor ID. More... | |
| uint8_t | warning |
| 0…= warning beeps More... | |
| uint8_t | sensor_text_id |
| GPS Sensor text mode ID. More... | |
| uint8_t | alarm_inverse1 |
| 01 inverse status More... | |
| uint8_t | alarm_inverse2 |
| 00 inverse status status 1 = no GPS Signal More... | |
| uint8_t | flight_direction |
| 119 = Flightdir. More... | |
| uint8_t | gps_speed_L |
| 8 = /GPS speed low byte 8km/h More... | |
| uint8_t | gps_speed_H |
| 0 = /GPS speed high byte More... | |
| uint8_t | latitude_ns |
| 000 = N = 48°39’988 More... | |
| uint8_t | latitude_min_L |
| 231 0xE7 = 0x12E7 = 4839 More... | |
| uint8_t | latitude_min_H |
| 018 18 = 0x12 More... | |
| uint8_t | latitude_sec_L |
| 171 220 = 0xDC = 0x03DC =0988 More... | |
| uint8_t | latitude_sec_H |
| 016 3 = 0x03 More... | |
| uint8_t | longitude_ew |
| 000 = E= 9° 25’9360 More... | |
| uint8_t | longitude_min_L |
| 150 157 = 0x9D = 0x039D = 0925 More... | |
| uint8_t | longitude_min_H |
| 003 3 = 0x03 More... | |
| uint8_t | longitude_sec_L |
| 056 144 = 0x90 0x2490 = 9360 More... | |
| uint8_t | longitude_sec_H |
| 004 36 = 0x24 More... | |
| uint8_t | distance_L |
| 027 123 = /distance low byte 6 = 6 m More... | |
| uint8_t | distance_H |
| 036 35 = /distance high byte More... | |
| uint8_t | altitude_L |
| 243 244 = /Altitude low byte 500 = 0m More... | |
| uint8_t | altitude_H |
| 001 1 = /Altitude high byte More... | |
| uint8_t | resolution_L |
| 48 = Low Byte m/s resolution 0.01m 48 = 30000 = 0.00m/s (1=0.01m/s) More... | |
| uint8_t | resolution_H |
| 117 = High Byte m/s resolution 0.01m More... | |
| uint8_t | unknown1 |
| 120 = 0m/3s More... | |
| uint8_t | gps_num_sat |
| GPS.Satellites (number of satellites) (1 byte) More... | |
| uint8_t | gps_fix_char |
| GPS.FixChar. More... | |
| uint8_t | home_direction |
| HomeDirection (direction from starting point to Model position) (1 byte) More... | |
| uint8_t | angle_x_direction |
| angle x-direction (1 byte) More... | |
| uint8_t | angle_y_direction |
| angle y-direction (1 byte) More... | |
| uint8_t | angle_z_direction |
| angle z-direction (1 byte) More... | |
| uint8_t | gyro_x_L |
| gyro x low byte (2 bytes) More... | |
| uint8_t | gyro_x_H |
| gyro x high byte More... | |
| uint8_t | gyro_y_L |
| gyro y low byte (2 bytes) More... | |
| uint8_t | gyro_y_H |
| gyro y high byte More... | |
| uint8_t | gyro_z_L |
| gyro z low byte (2 bytes) More... | |
| uint8_t | gyro_z_H |
| gyro z high byte More... | |
| uint8_t | vibration |
| vibration (1 bytes) More... | |
| uint8_t | ascii4 |
| 00 ASCII Free Character [4] More... | |
| uint8_t | ascii5 |
| 00 ASCII Free Character [5] More... | |
| uint8_t | gps_fix |
| 00 ASCII Free Character [6], we use it for GPS FIX More... | |
| uint8_t | version |
| uint8_t | stop |
| Stop byte. More... | |
| uint8_t | checksum |
| Lower 8-bits of all bytes summed. More... | |
The GPS sensor message Struct based on: https://code.google.com/p/diy-hott-gps/downloads.
Definition at line 188 of file messages.h.
| uint8_t gps_module_msg::alarm_inverse1 |
01 inverse status
Definition at line 193 of file messages.h.
| uint8_t gps_module_msg::alarm_inverse2 |
00 inverse status status 1 = no GPS Signal
Definition at line 194 of file messages.h.
| uint8_t gps_module_msg::altitude_H |
001 1 = /Altitude high byte
Definition at line 214 of file messages.h.
Referenced by build_gps_response().
| uint8_t gps_module_msg::altitude_L |
243 244 = /Altitude low byte 500 = 0m
Definition at line 213 of file messages.h.
Referenced by build_gps_response().
| uint8_t gps_module_msg::angle_x_direction |
angle x-direction (1 byte)
Definition at line 221 of file messages.h.
| uint8_t gps_module_msg::angle_y_direction |
angle y-direction (1 byte)
Definition at line 222 of file messages.h.
| uint8_t gps_module_msg::angle_z_direction |
angle z-direction (1 byte)
Definition at line 223 of file messages.h.
| uint8_t gps_module_msg::ascii4 |
00 ASCII Free Character [4]
Definition at line 231 of file messages.h.
| uint8_t gps_module_msg::ascii5 |
00 ASCII Free Character [5]
Definition at line 232 of file messages.h.
| uint8_t gps_module_msg::checksum |
Lower 8-bits of all bytes summed.
Definition at line 236 of file messages.h.
| uint8_t gps_module_msg::distance_H |
036 35 = /distance high byte
Definition at line 212 of file messages.h.
Referenced by build_gps_response().
| uint8_t gps_module_msg::distance_L |
027 123 = /distance low byte 6 = 6 m
Definition at line 211 of file messages.h.
Referenced by build_gps_response().
| uint8_t gps_module_msg::flight_direction |
119 = Flightdir.
/dir. 1 = 2°; 0° (North), 9 0° (East), 180° (South), 270° (West)
Definition at line 195 of file messages.h.
Referenced by build_gps_response().
| uint8_t gps_module_msg::gps_fix |
00 ASCII Free Character [6], we use it for GPS FIX
Definition at line 233 of file messages.h.
Referenced by build_gps_response().
| uint8_t gps_module_msg::gps_fix_char |
GPS.FixChar.
(GPS fix character. display, if DGPS, 2D oder 3D) (1 byte)
Definition at line 219 of file messages.h.
Referenced by build_gps_response().
| uint8_t gps_module_msg::gps_num_sat |
GPS.Satellites (number of satellites) (1 byte)
Definition at line 218 of file messages.h.
Referenced by build_gps_response().
| uint8_t gps_module_msg::gps_speed_H |
0 = /GPS speed high byte
Definition at line 197 of file messages.h.
Referenced by build_gps_response().
| uint8_t gps_module_msg::gps_speed_L |
8 = /GPS speed low byte 8km/h
Definition at line 196 of file messages.h.
Referenced by build_gps_response().
| uint8_t gps_module_msg::gyro_x_H |
gyro x high byte
Definition at line 225 of file messages.h.
| uint8_t gps_module_msg::gyro_x_L |
gyro x low byte (2 bytes)
Definition at line 224 of file messages.h.
| uint8_t gps_module_msg::gyro_y_H |
gyro y high byte
Definition at line 227 of file messages.h.
| uint8_t gps_module_msg::gyro_y_L |
gyro y low byte (2 bytes)
Definition at line 226 of file messages.h.
| uint8_t gps_module_msg::gyro_z_H |
gyro z high byte
Definition at line 229 of file messages.h.
| uint8_t gps_module_msg::gyro_z_L |
gyro z low byte (2 bytes)
Definition at line 228 of file messages.h.
| uint8_t gps_module_msg::home_direction |
HomeDirection (direction from starting point to Model position) (1 byte)
Definition at line 220 of file messages.h.
Referenced by build_gps_response().
| uint8_t gps_module_msg::latitude_min_H |
| uint8_t gps_module_msg::latitude_min_L |
231 0xE7 = 0x12E7 = 4839
Definition at line 200 of file messages.h.
Referenced by build_gps_response().
| uint8_t gps_module_msg::latitude_ns |
| uint8_t gps_module_msg::latitude_sec_H |
| uint8_t gps_module_msg::latitude_sec_L |
171 220 = 0xDC = 0x03DC =0988
Definition at line 202 of file messages.h.
Referenced by build_gps_response().
| uint8_t gps_module_msg::longitude_ew |
| uint8_t gps_module_msg::longitude_min_H |
| uint8_t gps_module_msg::longitude_min_L |
150 157 = 0x9D = 0x039D = 0925
Definition at line 206 of file messages.h.
Referenced by build_gps_response().
| uint8_t gps_module_msg::longitude_sec_H |
| uint8_t gps_module_msg::longitude_sec_L |
056 144 = 0x90 0x2490 = 9360
Definition at line 208 of file messages.h.
Referenced by build_gps_response().
| uint8_t gps_module_msg::resolution_H |
117 = High Byte m/s resolution 0.01m
Definition at line 216 of file messages.h.
| uint8_t gps_module_msg::resolution_L |
48 = Low Byte m/s resolution 0.01m 48 = 30000 = 0.00m/s (1=0.01m/s)
Definition at line 215 of file messages.h.
| uint8_t gps_module_msg::sensor_id |
| uint8_t gps_module_msg::sensor_text_id |
GPS Sensor text mode ID.
Definition at line 192 of file messages.h.
Referenced by build_gps_response().
| uint8_t gps_module_msg::start |
| uint8_t gps_module_msg::stop |
| uint8_t gps_module_msg::unknown1 |
120 = 0m/3s
Definition at line 217 of file messages.h.
| uint8_t gps_module_msg::version |
Definition at line 234 of file messages.h.
| uint8_t gps_module_msg::vibration |
vibration (1 bytes)
Definition at line 230 of file messages.h.
| uint8_t gps_module_msg::warning |
0…= warning beeps
Definition at line 191 of file messages.h.


How To convert AD / NTFS timestamps like pwdLastSet or lastLogonTimeStamp into Excel Date: Convert online: https://www.epochconverter.com/ldap Convert using Command Line: w32tm /ntte {serial} Convert using Excel formula: =(A1/10^11/8,64)-109205
Life of a SysAdmin
Here you can find some personal stories I posted lately.
-
A long time ago one of my managers told me “you should write a blog!”… I dismissed the idea back then mainly because I did not like following the trends and I did not want to make another Wordpress site on the internet… But yesterday late night while browsing memes on 9gag I came across this picture of a Japanese girl band whose name did not come to my mind…
-
Just a couple of links pointing to old and new friends sites. If you think your site should / should not appear here then send me a message!
-
Hey there - check out the awesome tee shirts I got over the past few years! Some of these cool designs may not be available to buy anymore - so this is history being made right here. ;-) I usually get them from Qwertee.com. They do ship to Europe and regularly have 2-for-1 discounts available.
-
Earthwatching rulz
-
Mein Luftkissenfahrzeug ist voller Aale. 🤣
-
429 Why don't we take a break? ☕
1/1


Data Warehouse is a data storage area that has been tested for security, so you can store your data here safely but not be afraid of being stolen by others.
The place to store various data that you can access at any time through the internet and where you can carry it. This very flexible storage area has a high level of security. To enter into your own data you must enter the password that you created when you registered in this Data Warehouse.
Some of the features and advantages that we provide for those of you who store data in this Data Warehouse.
Search Data
Don’t worry if your data is very large, the Data Warehoue provides a search engine, which is useful for making it easier to find data effectively saving time.
24 Hours Access
Access is given 24 hours a full morning to night and meet again in the morning, giving you comfort when you need data when urgent.
Print Out
Print out service gives you convenience if someday you need print data, just edit it all and just print it.
Security Code
Data Security is one of our best facilities. Allows for your files to be safer. The file can be secured with a code or password that you created, so only you can open the file.
wordfaang.com
Suspendisse ultrices at diam lectus nullam. Nisl, sagittis viverra enim erat tortor ultricies massa turpis. Arcu pulvinar aenean nam laoreet nulla.
UX Engineer
Suspendisse ultrices at diam lectus nullam. Nisl, sagittis viverra enim erat tortor


Mouseware uses a cryptographically secure random number generator based on your mouse movements to generate secure, memorable passwords. Passwords are generated entirely in the browser, no data is ever sent over the network. The generated passphrases are similar to those generated by Diceware or popularized by xkcd, with an emphasis on easy memorization.
Mouseware can now optionally use the diceware word list. Enable secure diceware password generation.
[1]1000 guesses/second is a worst-case web-based attack. Typically this is the only type of attack feasible against a secure website.
[2]100 billion guesses/second is a worst-case offline attack, when a hashed password database is stolen by someone with nontrivial technical and financial resources.


Match Play. Red trails 2-4 to 7. How should Red play 11?
pips Red=118 White=107
(CorrectAnswer= 0/0, ErrorScore= 0)
After you reject the super-safe 7/4*/3 and then also reject 7/6, 7/4* as still being too safe it seems obvious to play 7/4*, 6/5.
However, that play is a bad error due to technical inaccuracy. The play leaves 22 cover numbers next turn while 7/4*, 5/4 gives 24 cover numbers and in addition it makes 1s and 2s good for Red, those numbers being ones that don’t enter in White’s board if Red does get hit.
 A surprising result maybe but you can’t fault XG’s technical accuracy.
Always take more time when you roll a small double as it is surprising just how many ways it can be played.
However, that play is a bad error due to technical inaccuracy. The play leaves 22 cover numbers next turn while 7/4*, 5/4 gives 24 cover numbers and in addition it makes 1s and 2s good for Red, those numbers being ones that don’t enter in White’s board if Red does get hit.
 A surprising result maybe but you can’t fault XG’s technical accuracy.
Always take more time when you roll a small double as it is surprising just how many ways it can be played.
1. Cubeful 2-ply 7/4* 5/4 Eq.: +0.630 0.659 0.302 0.007 - 0.341 0.101 0.002 2. Cubeful 2-ply 7/4* 6/5 Eq.: +0.589 (-0.041) 0.651 0.288 0.007 - 0.349 0.104 0.002 3. Cubeful 2-ply 7/4* 7/6 Eq.: +0.528 (-0.102) 0.630 0.277 0.006 - 0.370 0.090 0.002 4. Cubeful 2-ply 6/4*(2) Eq.: +0.515 (-0.115) 0.640 0.252 0.006 - 0.360 0.097 0.002 5. Cubeful 2-ply 6/4* 5/4(2) Eq.: +0.470 (-0.160) 0.639 0.218 0.004 - 0.361 0.071 0.001


We offer best in the world, top quality fertility computers
Products
WORKING WITH YOUR BODY NATURALLY.
The scientifically proven, sophisticated fertility monitor that goes where you go. Our newest generation Lady-Comps are now equipped with 2 AAA batteries and able to sync to your computer. Lady-Comp gives you the freedom to enjoy natural fertility management.

The scientifically proven, sophisticated fertility monitor that goes where you go. Our newest generation Lady-Comps are now equipped with 2 AAA batteries and able to sync to your computer. Lady-Comp gives you the freedom to enjoy natural fertility management.
Lady-Comp is the intelligent fertility monitor — a next-generation computer that learns, analyzes and indicates ovulation with 99.3% accuracy
Features
Lady Comp is programmed with all natural family planning research data, containing a database of more than 900 000 cycles and uses bio-mathematical forecasting calculations as well as the very latest computer techniques.
Organizing romance with your partner around your most fertile days will ensure that your dream quickly becomes your reality.
The fertility computer takes your basal body temperature (BBT) every morning when you wake up with the most advanced temperature sensor (1/100 degrees accurate). It is 99.3% effective right from the start. A Pearl Index of 0.7 means that this 100-percent natural method is 99.3 percent safe and effective.
headquartered in Bangalore, India, was established in early 2017, by Mr.Pramod
About Us
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Necessitatibus aliquid maiores, voluptatum ex. Accusantium, eum distinctio laudantium. Perferendis dolor, corporis quasi? Tempore quod molestiae quis cumque pariatur dolore vel sit, fugit delectus quasi reprehenderit officia voluptate incidunt, culpa odit impedit qui dolorum fugiat. Quidem possimus reprehenderit, quae recusandae voluptatibus magnam!
Ratione facilis quod laborum eaque illo dolore blanditiis nobis dicta voluptatem fugit optio, eveniet non dolor quia delectus, sint, dignissimos atque porro consequuntur unde. Soluta ex necessitatibus delectus saepe aliquam, culpa officiis doloremque, ipsa facere hic, voluptatem accusantium veniam, quasi! Explicabo accusantium sint, corporis consequuntur fugit ipsam, dolorum excepturi adipisci.
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Necessitatibus aliquid maiores, voluptatum ex. Accusantium, eum distinctio laudantium. Perferendis dolor, corporis quasi? Tempore quod molestiae quis cumque pariatur dolore vel sit, fugit delectus quasi reprehenderit officia voluptate incidunt, culpa odit impedit qui dolorum fugiat. Quidem possimus reprehenderit, quae recusandae voluptatibus magnam!
Ratione facilis quod laborum eaque illo dolore blanditiis nobis dicta voluptatem fugit optio, eveniet non dolor quia delectus, sint, dignissimos atque porro consequuntur unde. Soluta ex necessitatibus delectus saepe aliquam, culpa officiis doloremque, ipsa facere hic, voluptatem accusantium veniam, quasi! Explicabo accusantium sint, corporis consequuntur fugit ipsam, dolorum excepturi adipisci.
Please contact us via Email or call for any inquiries concerning product servicing. Most problems can be solved without having to send the product in.
Contact


The Assert task adds an assertion capability to Ant projects. This task works in a manner very similar to the Java assert keyword, and provides a limited "design by contract" facility to Ant. This is very useful for testing build scripts prior to putting them into production.
The Assert task verifies that a particular boolean condition is met, and throws a BuildException if it is not.
Also like Java's assert keyword, the Assert task must be 'turned on' using the property ant.enable.asserts . If not set, or is set to false , the Assert task works exactly like the Sequential task. If the Variable task is used to define this property, then it can be turned on and off as needed throughout a build.
This task can hold other tasks including Assert.
Thie assert task may contain a single conditional element known by ANT, or one of the following additional conditions: IsPropertyTrue , IsPropertyFalse , StartsWith , EndsWith , IsGreaterThan , IsLessThan and conditions. See the If task for examples of using these conditionals.
Table 4.1. Assert Task Attributes
| Attribute | Description | Default | Required |
|---|---|---|---|
| name | The name of the property to test for. This is a shortcut for specifying an <equals> condition. | none | No. However, if specified, the 'value' attribute must also be present |
| value | The value to test for, implies . If the value in the project is different than this value, a BuildException will be thrown and the build will stop. | none | No, unless the 'name' attribute is specified. |
| execute | Should the tasks contained in this task be executed? It may be useful to set this to false when testing build files. | True | No |
| failonerror | Should the build halt if the assertion fails? Setting this to false is contrary to the intented use of assertions, but may be useful in certain situations. | True | No |
In the following example, the first assert task checks that the wait property exists and does not execute the echo and sleep tasks. The second assert task checks that the wait property exists, has a value of 2, and executes the echo task.
<property name="wait" value="2"/> <assert execute="false"> <isset property="wait" /> <sequential> <echo> Waiting ${wait} seconds... Click the red button to stop waiting. </echo> <sleep seconds="${wait}"/> </sequential> </assert> <assert name="wait" value="2" execute="true"> <sequential> <echo>done waiting!</echo> </sequential> </assert> |
The next example shows Assert being used in a unit test for the "limit" task:
<property name="ant.enable.asserts" value="true"/> <target name="test2"> <!-- should not stop 'sleep' task, should print out '_passed_' --> <stopwatch name="timer"/> <limit maxwait="5"> <sleep seconds="1"/> <echo>_passed_</echo> </limit> <stopwatch name="timer" action="total"/> <assert message="Too much time."> <islessthan arg1="${timer}" arg2="2"/> </assert> </target> |
If the ant.enable.asserts property is set to false, then in the above example, the echo , sleep , and echo tasks will all execute.
Copyright © 2003 Ant-Contrib Project. All rights Reserved.


Pig Dice
Rules:
If you want to play this game,click the play button to refresh the page
If the die are equal then the score is doubled
Otherwise,the score is just the sum of thetw
Player 1
Roll
Hold
Dice Roll:
Round Total:
Total Score:
Player 2
Roll
Hold
Dice Roll:
Round Total:
Total Score:
Play


Physically-based rendering using
MetallicMaterial
model: OBJ fire hydrant with PBR textures - [
model info
]


Choclate Pizza
POSTED ON 1ST OF DEC 2021 / DESERTS
Smooth chocolate-hazelnut spread over hot crust. Sprinkle chopped bittersweet chocolate and white chocolate over. Bake until chocolate begins to melt, about 2 minutes. Sprinkle chopped hazelnuts over, cut into wedges, and serve.
Smooth chocolate-hazelnut spread over hot crust. Sprinkle chopped bittersweet chocolate and white chocolate over. Bake until chocolate begins to melt, about 2 minutes. Sprinkle chopped hazelnuts over, cut into wedges, and serve.
Smooth chocolate-hazelnut spread over hot crust. Sprinkle chopped bittersweet chocolate and white chocolate over. Bake until chocolate begins to melt, about 2 minutes. Sprinkle chopped hazelnuts over, cut into wedges, and serve.


XSM(1) XSM(1) NAME xsm - X Session Manager SYNOPSIS xsm [-display display] [-session sessionName] [-verbose] DESCRIPTION xsm is a session manager. A session is a group of applications, each of which has a particular state. xsm allows you to create arbitrary ses‐ sions - for example, you might have a "light" session, a "development" session, or an "xterminal" session. Each session can have its own set of applications. Within a session, you can perform a "checkpoint" to save application state, or a "shutdown" to save state and exit the session. When you log back in to the system, you can load a specific session, and you can delete sessions you no longer want to keep. Some session managers simply allow you to manually specify a list of applications to be started in a session. xsm is more powerful because it lets you run applications and have them automatically become part of the session. On a simple level, xsm is useful because it gives you this ability to easily define which applications are in a session. The true power of xsm, however, can be taken advantage of when more and more applications learn to save and restore their state. OPTIONS -display display Causes xsm to connect to the specified X display. -session sessionName Causes xsm to load the specified session, bypassing the session menu. -verbose Turns on debugging information. SETUP .xsession file Using xsm requires a change to your .xsession file: The last program executed by your .xsession file should be xsm. With this configuration, when the user chooses to shut down the session using xsm, the session will truly be over. Since the goal of the session manager is to restart clients when logging into a session, your .xsession file, in general, should not directly start up applications. Rather, the applications should be started within a session. When xsm shuts down the session, xsm will know to restart these applications. Note however that there are some types of applica‐ tions that are not "session aware". xsm allows you to manually add these applications to your session (see the section titled Client List). SM_SAVE_DIR environment variable If the SM_SAVE_DIR environment variable is defined, xsm will save all configuration files in this directory. Otherwise, they will be stored in the user's home directory. Session aware applications are also encour‐ aged to save their checkpoint files in the SM_SAVE_DIR directory, although the user should not depend on this convention. Default Startup Applications The first time xsm is started, it will need to locate a list of applica‐ tions to start up. For example, this list might include a window man‐ ager, a session management proxy, and an xterm. xsm will first look for the file .xsmstartup in the user's home directory. If that file does not exist, it will look for the system.xsm file that was set up at installa‐ tion time. Note that xsm provides a "fail safe" option when the user chooses a session to start up. The fail safe option simply loads the default applications described above. Each line in the startup file should contain a command to start an appli‐ cation. A sample startup file might look this: <start of file> twm smproxy xterm <end of file> STARTING A SESSION When xsm starts up, it first checks to see if the user previously saved any sessions. If no saved sessions exist, xsm starts up a set of default applications (as described above in the section titled Default Startup Applications). If at least one session exists, a session menu is pre‐ sented. The [-session sessionName] option forces the specified session to be loaded, bypassing the session menu. The session menu The session menu presents the user with a list of sessions to choose from. The user can change the currently selected session with the mouse, or by using the up and down arrows on the keyboard. Note that sessions which are locked (i.e. running on a different display) can not be loaded or deleted. The following operations can be performed from the session menu: Load Session Pressing this button will load the currently selected session. Alternatively, hitting the Return key will also load the currently selected session, or the user can double click a session from the list. Delete Session This operation will delete the currently selected session, along with all of the application check‐ point files associated with the session. After pressing this button, the user will be asked to press the button a second time in order to confirm the operation. Default/Fail Safe xsm will start up a set of default applications (as described above in the section titled Default Startup Applications). This is useful when the user wants to start a fresh session, or if the ses‐ sion configuration files were corrupted and the user wants a "fail safe" session. Cancel Pressing this button will cause xsm to exit. It can also be used to cancel a "Delete Session" oper‐ ation. CONTROLLING A SESSION After xsm determines which session to load, it brings up its main window, then starts up all applications that are part of the session. The title bar for the session manager's main window will contain the name of the session that was loaded. The following options are available from xsm's main window: Client List Pressing this button brings up a window containing a list of all clients that are in the current session. For each client, the host machine that the client is running on is presented. As clients are added and removed from the session, this list is updated to reflect the changes. The user is able to control how these clients are restarted (see below). By pressing the View Properties button, the user can view the session management properties associated with the currently selected client. By pressing the Clone button, the user can start a copy of the selected application. By pressing the Kill Client button, the user can remove a client from the session. By selecting a restart hint from the Restart Hint menu, the user can control the restarting of a client. The following hints are available: - The Restart If Running hint indicates that the client should be restarted in the next session if it is con‐ nected to the session manager at the end of the current session. - The Restart Anyway hint indicates that the client should be restarted in the next session even if it exits before the current session is terminated. - The Restart Immediately hint is similar to the Restart Anyway hint, but in addition, the client is meant to run continuously. If the client exits, the session manager will try to restart it in the current session. - The Restart Never hint indicates that the client should not be restarted in the next session. Note that all X applications may not be "session aware". Applications that are not session aware are ones that do not support the X Session Management Pro‐ tocol or they can not be detected by the Session Man‐ agement Proxy (see the section titled THE PROXY). xsm allows the user to manually add such applications to the session. The bottom of the Client List window con‐ tains a text entry field in which application commands can be typed in. Each command should go on its own line. This information will be saved with the session at checkpoint or shutdown time. When the session is restarted, xsm will restart these applications in addi‐ tion to the regular "session aware" applications. Pressing the Done button removes the Client List win‐ dow. Session Log... The Session Log window presents useful information about the session. For example, when a session is restarted, all of the restart commands will be dis‐ played in the log window. Checkpoint By performing a checkpoint, all applications that are in the session are asked to save their state. Not every application will save its complete state, but at a minimum, the session manager is guaranteed that it will receive the command required to restart the appli‐ cation (along with all command line options). A window manager participating in the session should guarantee that the applications will come back up with the same window configurations. If the session being checkpointed was never assigned a name, the user will be required to specify a session name. Otherwise, the user can perform the checkpoint using the current session name, or a new session name can be specified. If the session name specified already exists, the user will be given the opportunity to specify a different name or to overwrite the already existing session. Note that a session which is locked can not be overwritten. When performing a checkpoint, the user must specify a Save Type which informs the applications in the session how much state they should save. The Local type indicates that the application should save enough information to restore the state as seen by the user. It should not affect the state as seen by other users. For example, an editor would create a temporary file containing the contents of its editing buffer, the location of the cursor, etc... The Global type indicates that the application should commit all of its data to permanent, globally accessi‐ ble storage. For example, the editor would simply save the edited file. The Both type indicates that the application should do both of these. For example, the editor would save the edited file, then create a temporary file with informa‐ tion such as the location of the cursor, etc... In addition to the Save Type, the user must specify an Interact Style. The None type indicates that the application should not interact with the user while saving state. The Errors type indicates that the application may interact with the user only if an error condition arises. The Any type indicates that the application may inter‐ act with the user for any purpose. Note that xsm will only allow one application to interact with the user at a time. After the checkpoint is completed, xsm will, if neces‐ sary, display a window containing the list of applica‐ tions which did not report a successful save of state. Shutdown A shutdown provides all of the options found in a checkpoint, but in addition, can cause the session to exit. Note that if the interaction style is Errors or Any, the user may cancel the shutdown. The user may also cancel the shutdown if any of the applications report an unsuccessful save of state. The user may choose to shutdown the session with our without performing a checkpoint. HOW XSM RESPONDS TO SIGNALS xsm will respond to a SIGTERM signal by performing a shutdown with the following options: fast, no interaction, save type local. This allows the user's session to be saved when the system is being shutdown. It can also be used to perform a remote shutdown of a session. xsm will respond to a SIGUSR1 signal by performing a checkpoint with the following options: no interaction, save type local. This signal can be used to perform a remote checkpoint of a session. THE PROXY Since not all applications have been ported to support the X Session Man‐ agement Protocol, a proxy service exists to allow "old" clients to work with the session manager. In order for the proxy to detect an applica‐ tion joining a session, one of the following must be true: - The application maps a top level window containing the WM_CLIENT_LEADER property. This property provides a pointer to the client leader window which contains the WM_CLASS, WM_NAME, WM_COMMAND, and WM_CLIENT_MACHINE properties. or ... - The application maps a top level window which does not contain the WM_CLIENT_LEADER property. However, this top level window contains the WM_CLASS, WM_NAME, WM_COMMAND, and WM_CLIENT_MACHINE properties. An application that support the WM_SAVE_YOURSELF protocol will receive a WM_SAVE_YOURSELF client message each time the session manager issues a checkpoint or shutdown. This allows the application to save state. If an application does not support the WM_SAVE_YOURSELF protocol, then the proxy will provide enough information to the session manager to restart the application (using WM_COMMAND), but no state will be restored. REMOTE APPLICATIONS xsm requires a remote execution protocol in order to restart applications on remote machines. Currently, xsm supports the rstart protocol. In order to restart an application on remote machine X, machine X must have rstart installed. In the future, additional remote execution protocols may be supported. SEE ALSO smproxy(1), rstart(1) AUTHORS Ralph Mor, X Consortium Jordan Brown, Quarterdeck Office Systems X Version 11 xsm 1.0.2 XSM(1)


What is the difference between Margin, Border, and Padding?
This box is a div; a container to put stuff in, in this case, text... This "div" has a solid gray border around it which is 5 pixels wide.
The space between this text and the border is known as padding. This div has padding of 20px all around.
Margins clear a space around an element. Margins are like padding, except they are the space from the edges of our divs starting at the border. This particular div has a margin of 300px from the left border to the left edge of the screen.


Data updated: September 13, 2017
GraFa is a faceted browser for Wikidata triples made by José Ignacio Moreno and Aidan Hogan.
Important: GraFa is currently in development. Certain features or options can change in the future. Data updates won't be very frequent. Next update from dataset expected around mid March.
GraFa uses all Wikidata triples, so you need to correct the data from Wikidata. Changes will be visible in the next update. The date of the last update will be displayed in this page.
Those are identifiers for a resource. If you see them, it is because that resource does not have a label in the selected language. You can add a label directly in Wikidata, the change will be visible in the next update.
Yes. GraFa will use the labels from Wikidata for the specified language. Although, we will need help to translate the GraFa interface, if you want to help translate GraFa, contact us.
Please let us known, you can post on the GitHub Issue Tracker


{% import "_includes/forms" as forms %} {% block content %}
{{ 'Version: {version}' | t({ version: version }) }}
{{ description }}
Makes all log messages get logged.
(LogLevel::Warning
and LogLevel::Error
are always logged).
{{ "Dumps the POST data back to the page & prevents redirects, so you can see if your form is submitting the correct data. (This setting is ignored if you're submitting by ajax - use your developer console to check that!)" | t }}


Projects
Timesheet
Leave
Rojit Khayargoli
Active Employees
Reports
Active Employees
Rojit Khayargoli
9843080993


{% extends "template.html" %} {% block content %}
Update student grade for the following course:
Course name:
{{grades[1]}}
Student first name:
{{grades[2]}}
Student last name:
{{grades[3]}}
Update grade to:
Go back to home page
{% endblock %}


Govt retirees lose RM190,000 to Macau scammers
ALOR STAR, Nov 25 — Two government retirees lost a total of RM190,000 after being duped by a Macau scam syndicate in two separate incidents in Kota Setar district recently.
Kota Setar district police chief ACP Mohd Rozi said in the first incident on Nov 13, the 49-year-old victim received a call from a man who introduced himself as a representative of Telekom Malaysia based in Kuala Lumpur.
“The man informed the victim that he had a outstanding bill before the line was transferred to a man claiming to be a police officer from the Kuala Lumpur police contingent headquarters, who told him that he was involved in the movement of illegal funds.
“The victim was then instructed to transfer money to a bank account for bail and investigations payment. The worried victim then made 29 transactions totalling RM180,000 to the account,” he said in a statement.
He said using the same modus operandi, the syndicate, on Nov 18, scammed another retiree, aged 62, who ended up losing 9,000 to them.
Meanwhile, Mohd Rozi said 65 police reports over Macau scam cases were lodged in the district between January and October, involving losses totalling RM1.67 million.
He said police had made several arrests of those who conspired with the scammers by providing them bank account numbers.
Mohd Rozi advised the public not to panic easily when receiving such calls as the police, courts or bank have no authority to order cash transfers to third party accounts. — Bernama


abstract class BranchOperation<T> : BinaryOperation<T>
BranchOperation(func: (Arguments<T>) -> T) |
open fun execute(arguments: Arguments<T>): T
Applies the operations function to the argument(s) given. |
class IfGreater : BranchOperation<Double>
Performs a branch by comparing two arguments using the greater than operator. |
|
class IfLessThanOrEqualTo : BranchOperation<Double>
Performs a branch by comparing two arguments using the less than or equal to operator. |


Getting Started - Quick start
Involt works like bridge between hardware and software. It's HTML/CSS framework bundled with hardware interactions - just define parameters of what to send where with CSS classes. The hardware part is reduced to minimum where framework handles only the communication and triggering functions. Involt from technical point of view does two things. It transfers variables between Arduino and app so they are accessible from both sides. Secondly, it contains UI kit generated by CSS classes and manipulated by JQuery.
The purpose of Involt is fast and easy prototyping - for more details about the project read the about page
What communication methods are supported?
- Serial - desktop
- Bluetooth (2.0/classic) - desktop and mobile
- Bluetooth LE (early beta) - mobile
Even if it's HTML based, currently Involt has no IoT online support. However, for prototyping purpose it's rarely required to have this kind of communication or online service inluded at early stage.
How to install
Involt on desktop is created on top of Chrome API as offline Chrome Packaged App. It's easy to setup and suitable for Involt where Chrome dependency is not that important at all. The project works on Windows, OS X and Chrome OS (On Linux serial should work). For mobile installation go to Mobile page.
This guide uses serial connection by default.
- Install Google Chrome.
- Download and unpack Involt.
- In Chrome go to tools > extensions.
- Toggle Developer mode
- Click "Load unpacked extension..." and choose www folder.
Now open your project with launch button or Chrome App Launcher. If everything is ok you should see the window on the right. On the screen you should see available serial port lists and your device plugged in.
* For standalone usage you can use node-webkit by pasting the www folder content into main folder.
Adding UI element
To create Involt HTML element, describe its type and parameters as CSS classes. By doing this, the device is controlled without actually programming from app side. These parameters are consistent for each object so understanding how basic button works will similarly adapt to other UI elements. Below are two most basic examples. Read more: HTML UI & CSS syntax.
ard [element] [pin] [value] [parameters]
Read data from Arduino
Reading data from Arduino is easy. Everything you need is the involtSend(pinIndex, value) function inside included (involt-basic) sketch and HTML UI element you wish to communicate in index.html. Value of pin is stored and updated automatically from both sides.
Involt requires to write code from both sides, usually it's one line in app and one in sketch. The advantage of this solution is the fact that it's easier to adapt existing device and you can easily operate with basics of programming in Arduino IDE without any advanced topics.
It's highly recommended that you do most of the value calculations within your device. Otherwise you need to use in-app functions which is harder.
Add this to arduino sketch:
void loop(){
involtReceive();
involtSend(0, analogRead(A0));
delay(2);
}...
Now add this element to index.html file. After connecting something to A0 (knob or anything else) you should see the value changing.
Send data to Arduino
Sending data requires digitalWrite or analogWrite with involtPin[pinIndex] array value. The values in this array are updated automatically. Sending and receiving can be related to any variable you want - not only pin states. You can use this array to store values for sketch functions.
void loop(){
involtReceive();
analogWrite(5, involtPin[5]);
}...
The button will send pwm value 123 to pin 5 and turn on connected LED.
Summary
As you see, using Involt is easy to understand. There is more you can do with Involt and it's widely explained in next chapters. Playing with examples is good idea to practice.
Sounds trivial? Maybe. Creating layouts with CSS sounds like something banal but have you ever thought about adding hardware interactions with it directly, without any online controled services or figuring out how to establish connection? With Involt, combining interactions is easy as never before and opens new ways in prototyping and further development. Calling this way of designing "tangible css" is something well describing what actually happens when you use Involt.
Depending on your workflow, whether its focused on layout, front end, or device itself, developing and iterating both sides of project at once is crucial and can't be separated. It's good to know how Involt works and what values must be transfered before starting the project (not everything must be send to app/device). It's easy to start from both ways - from app to device and vice versa. Thanks to CSS, another great thing in Involt is the ease with which you can hook up the hardware when you discovered Involt halfway through the project.


To become a Trooper, you must be level 20 or higher and have obtained Master Gwain's recommendation.
You have his recommendation, but you do not meet the level requirement. Come back when you have reached level 20 or higher.


# cookie || query || json session_token_support=jsonTo test GET set the "session_token_support" property to "query" in the server.conf file and restart the server application.
# cookie || query || json session_token_support=queryTo test with Redis, use RedisSession and include RedisCacheDriver in the project.


#include <mdgame.h>
Public Attributes | |
| string | name |
| Game name. | |
| string | title |
| Game title. | |
| string | log_name |
| Name of system log file. | |
| string | pack_dir_name |
| name of PackDir image file without any extensions. | |
| DWord | system_pool_size |
| size of mobile dragon' internal memory pool. | |
| DWord | log_level |
| mobile dragon system log detail level ( 0 - 5 ). | |
| DWord | runs_per_second |
| how many times per second MDGame->Update() will be called. | |
| DWord | symbian_uid |
| your application's symbian uid. | |
| DWord | palm_creator_id |
| your application' palm CREATORID. |


FEDERAL POLYTECHNIC NASARAWA
Computer science Department
NAME: Japhet Adams
REG NO: NCS/2508
COURSE CODE: COM225
ASSIGNMENT ON BIBLIOGRAPHY ABOUT MYSELF
My name is Japhet Adams.i am from jaba L.G.A in Kaduna state. I was born on 24th May, 1999.I completed My primary School
(FSLC) in 2009 in Destiny International School Kuchikau Karu L.g.a Nasarawa State,and proceded to my junior and senior
secondary School which i garduated receiving my Certificate (SSCE) in 2014 in ECWA Bishara Secondary school Gusau, Zamfara
State.I am currently studying Computer Science in the school of information and communication Technology, Federal Polytechnic
Nasarawa, Nasarawa State and by Gods Grace,I am rounding up my (ND) National Diploma this Year (2019).


{% extends "app/layout.html" %} {% block content %}
Choose a starting point below to get started and explore the timeline for events affecting Academies
... with blood sweat and tears


Hi ${request.identity['user']}
Hello from, ${h.indicator.bold('tong')} owned by tong
${h.call_partial('indicator.partials:something', name='Partial')}


Hello!
My name is Pablo Medina. I am from Argentina, South America.
I live in Puerto Madryn, a beautiful place in Patagonia.
I work as SysAdmin. As you may know, i take care of servers. I am the guy that read logs, keep your server up-to date, and check uptime at 3AM.
I do all my work online, managing remote servers from different places.
All my work was done via Rentacoder (now Freelancer) since 2002. I managed to be ranked 289 in their "All Coder competition ranking", with 405 jobs completed with an average rating of 9.91.
Since 2008, i started to use oDesk (now UpWork) with great success. On July 2020 i earned the Top Rated Plus
badge, a
status that reflect my success on large / long-term contracts.
Please check my profile there and post a bid for me if you are interested in my services, or you can check my expertise areas to know more about me.
Pablo E. Medina


{% extends "layout.html" %} {% from "form.html" import form_field, form_field_errors %} {% block title %}Revoke YubiKey{% endblock %} {% block content %}
Enter your revocation code below. Once revoked, the YubiKey will become disabled and the code will be invalidated. Note that you will NOT be able to use the revoked YubiKey to access your account. If you have multiple YubiKeys connected to it, you may log in using one of the enabled ones. Once logged in, you will be able to re-enable the revoked YubiKey, should you wish to do so. If so, you will need to generate a new revocation code for the key
Back {% endblock %}


NFL fashion files: The show-stopping looks of Week 11
by ESPN staffAnother week of NFL action, another chance for your favorite football players to turn the stadium tunnel into their runway.
From Canadian tuxedos (shoutout Minshew Mania) to Lamar Jackson merch (get yourself a teammate as supportive as Matt Skura), the league's finest did not disappoint with their outfit selections.
They also didn't disappoint with their shoe game. Specifically, Stefon Diggs donned an awesome, meme-inspired pair of cleats.
Oh, did we mention there were florals? Because DeAndre Hopkins brought out the florals. ... It's called fashion, look it up.
Without further ado, some of the most memorable looks from Week 11:


--- layout: post-template title: "And If Both Worlds" postHeading: "And If Both Worlds" subHeading: "A poem" tags: grief poetry related: grief date: "17 Aug 2018" image: "/img/And-If-Both-Worlds/And-If-Both-Worlds-Photo-by-Jake-Thacker-on-Unsplash.jpg" credit: "Photo by Jake Thacker on Unsplash" featured: "" featuredImage: "/img/And-If-Both-Worlds/And-If-Both-Worlds-Photo-by-Jake-Thacker-on-Unsplash-f.jpg" ---
Grief and the beyond
. . .
And if both worlds came together,
That of the living,
And that of the dead,
Then you could visit sometime –
Just for the briefest of moments.
And I would feel the press of your palm,
Soft against my cheek.
And draw comfort
That this world cannot give.
. . .
First published on The Kalahari Review


About
Projects
Contact
Hey I'm Mohamed.
a web developer
These are some of my projects...
YelpCamp
GuestBook
Pomodoro Clock
Random Quote Machine
Show All
Let's work together...
How do you take your coffee?
GitHub
Linkedin
FCC


Text Annotation Tool
Home
(current)
Samples
Annotate
New Sample
Uncompleted Sample
{% block content %} {% endblock %} {% block scripts %} {% endblock %}


- IL_TGA_CREATE_STAMP
- Sets whether .tga files are saved with a "postage stamp" in
their extension fields (IL_TRUE or IL_FALSE accepted).
- IL_JPG_QUALITY
- Sets the quality .jpg files are saved at. Valid values are in
the 0-99 range, with 99 being the best quality.
- IL_PNG_INTERLACE
- Tells DevIL to save .png files interlaced.
- IL_TGA_RLE
- Tells DevIL to save .tga files with RLE-compressed data.
- IL_BMP_RLE
- Tells DevIL to save .bmp files with RLE-compressed data.
- IL_SGI_RLE
- Tells DevIL to save .sgi files with RLE-compressed data.
- Param
- The value to set the mode with.
Remarks
ilSetInteger is ilGetInteger's counterpart.
Error Codes
IL_INVALID_ENUM - Mode was an invalid
enum.
IL_INVALID_PARAM - Param was not in range.
See Also
ilGetBoolean,
ilGetBooleanv, ilGetInteger, ilGetIntegerv


Rows:
10
100
1,000
10,000
30,000
50,000
100,000
Cols:
5
10
20
50
100
Pinned:
0
1
2
3
4
5
Width:
800px
1000px
2000px
100% (fit to screen)
Height:
400px
800px
4000px
100% (fit to screen)
Group Headers:
Yes
No
Style:
-none-
Fresh
Dark
Selection:
-none-
Checkbox
Single
Multiple
Editable:
Yes
No
Group By:
-none-
Continent
Language
Continent, Language
Language, Continent
Group Type:
First Col
Row
Expand All
Collapse All


Search Bungie
Wild-card search Bungie accounts by name. Note that sometimes these are
different than gamertags.
Not all Destiny accounts are active or in clans, so some links will strike themselves out when clicked.
No results found
| Name | Clan | ||||
|---|---|---|---|---|---|
| {{account.name}} |
|
|
|
|
Clan
Clan
|