{% set page = 'use-cases' %} {% set title = 'Collective Knowledge use cases' %} {% extends 'ck.html' %} {% block content %}
We made a special effort to simplify CK installation with minimal dependencies across Linux, Windows and MacOS. You just need Git client and Python 2.7+ or 3.3+. Just try it yourself as described here. You can then follow a simple tutorial to get the first feeling about CK capabilities (portable, customizable and reusable workflows and artifacts with a portable package manager).
Feel free to reuse or extend CK repositories, workflows, software detection plugins, portable packages and modules already shared by the community!
List of practical CK use cases from the community:
CK allows users to provide a common structure to their local ad-hoc code and data, and pack them with associated CK Python wrappers and JSON API into CK repositories (a - typical ad-hoc experimental packs for Artifact Evaluation, b - unified and reusable experimental repositories such as the one for CGO'17 paper or ACM ReQuEST tournaments). This allows the community to collaboratively validate, improve and build upon shared research artifacts thus enabling practical open science as described in the ACM ReQuEST-ASPLOS'18 proceedings front matter and this interactive and reproducible paper.
Such repositories can be easily shared and reused via public or private services including GitHub, BitBucket and GitLab. We keep track of some CK repositories, workflows, software detection plugins, portable packages and reusable CK modules. Feel free to add your own ones! In the future, we would like to assign DOI for stable artifacts and make a web-service to automatically find their location.
For example, Association for Computing Machinery (ACM) evaluates Collective Knowledge technology to share artifacts and experimental workflows as reusable and customizable components along with reproducible publications (see their video about CK).
ReQuEST consortium is also developing a scalable tournament framework, a common experimental methodology and an open repository powered by CK for continuous evaluation and optimization of the quality vs. efficiency Pareto optimality of a wide range of real-world applications, libraries and models across the whole hardware/software stack on complete platforms. See ACM proceedings, results report and live scoreboard.
Researchers can now use CK SDK to convert their complex and ad-hoc experimental scripts into unified CK workflows assembled from shared CK artifacts as LEGO bricks:
Furthermore, CK has its own portable package manager for Linux, Windows, Android and MacOS to automatically adapt such workflows to underlying software, detect multiple versions of installed dependencies which can co-exist and used in parallel (see available CK software detection plugins), and automatically install missing packages:
Such approach can considerably simplify artifact evaluation and validation of experimental results at conferences and journals. Furthermore, such workflows can be reused and collaboratively improved by the community (rather than just archiving Docker images which become quickly outdated) thus enabling practical, agile and open research!
For example, experimental workflow for the CGO'17 article from the University of Cambridge researchers which won distinguished artifact award was implemented using CK:
CK has an integrated web server allowing users to quickly prototype various web-based dashboards to run their workflows and analyze experimental results in workgroups. CK even allows creation of interactive reports and articles assembled from CK artifacts.
Here are some real examples of practical CK dashboards and interactive articles:
CK-powered interactive and reproducible article on collaborative auto-tuning and machine leanring
PDF snapshot of the interactive CK dashboard from the CGO'17 distinguished artifact
cKnowledge.org/repo: web access to a public CK repository of knowledge hosted in Azure cloud
Furthermore, we can now generate the whole collaborative websites using CK:
ADAPT workshop series: [ adapt-workshop.org ] , [ CK GitHub repo ]
Artifact Evaluation for computer systems conferences: [ cTuning.org/ae ] , [ CK GitHub repo ]
non-profit cTuning foundation: [ cTuning.org ]
Grigori Fursin's personal website with all cross-linked CK artifacts from past R&D: [ fursin.net/research ]
Integrated CK web server combined with unified JSON API of CK components allows workflows running on different machines to interact with each other via JSON-based web interfaces. This, in turn, allows users to effectively crowdsource experiments across diverse platforms (mobile devices, tablets, laptops, servers, cloud, supercomputers) provided by supporters similar to SETI@HOME. Results can be aggregated in public or private CK repositories for further visualization, analysis and improvement.
Colleagues from the Imperial College London used CK to crowdsource OpenCL compiler bug detection (HiPEAC technology transfer award winner):
CK helps our partners collaboratively benchmark their workloads such as deep learning across diverse platforms. You can test a simple example of compiling and running some shared workload on your own machine as follows:
$ ck pull repo:ck-autotuning $ ck pull repo:ctuning-programs
You can see shared programs in the CK format (JSON meta information describing how to compile and run shared program with all dependencies and data sets):
$ ck list program
You can now compile a given program simply as follows:
$ ck compile program:cbench-automotive-susan --speed
Note, that CK will detect all available versions of required compilers (GCC, LLVM, ICC ...) and libraries on your system using customizable cross-platform package and environment manager with JSON API and meta. If some software dependencies are missing, CK will automatically install required packages as described here.
Now you can run a given workload simply as follows:
$ ck run program:cbench-automotive-susan
CK will ask you which command line to use and will automatically detect or install all required data sets.
If you have Android NDK/SDK installed on your host machine and Android device connected via ADB, you can simply compile and run the same problem on this device as follows:
$ ck compile program:cbench-automotive-susan --speed --target_os=android21-arm-v7a $ ck run program:cbench-automotive-susan --target_os=android21-arm-v7a
Arm uses such CK workflows together with low-level tools to automate benchmarking and optimization of realistic workloads across diverse hardware.
High-level CK workflows together with unified JSON API allowed us to implement universal, customizable, multi-objective and multi-dimensional autotuning as described here.
Furthermore, we can now crowdsource exploration of large and non-linear design and optimization spaces to improve performance, energy, accuracy, memory consumption and other characteristics or automatically detect bugs across diverse workloads and platforms provided by volunteers.
You can check our shared workflow to crowdsource optimization as follows:
$ ck pull repo:ck-crowdtuning $ ck crowdsource experiment
For example, you can execute shared workflow for collaborative program optimization with all related artifacts, and start participating in multi-objective crowdtuning simply as follows:
$ ck crowdtune program
You can also crowd-tune GCC on Windows as follows:
$ ck crowdtune program --gcc --target_os=mingw-64
If you have GCC or LLVM compilers installed, you can start continuously crowd-tune their optimization heuristics in a quiet mode (for example overnight) via
$ ck crowdtune program --llvm --quiet $ ck crowdtune program --gcc --quiet
This experimental workflow will be optimizing different shared workloads for multiple objectives (execution time, code size, energy, compilation time, etc) using all exposed design and optimization knobs, while sending most profitable optimization choices to the public CK-based server.
CK server will, in turn, perform on-line learning to classify optimization versus workloads which can be useful for compiler/hardware designers and performance engineers (described in more detail in this article).
You can even use our small Android application to crowdsource tuning of GCC and LLVM compiler optimization heuristics while continuously learning and aggregating optimization results in the public CK repository.
You can also participate in crowdtuning of popular third-party OpenCL, OpenMP and CUDA-based mathematical libraries as described here.
Having a common experimental infrastructure allows us to build reusable, realistic, diverse, and continuously evolving training sets in a common format (programs, data sets, models, unexpected behavior, mispredictions) with the help of our partners and the community.
See the following examples of shared training sets:
Such realistic training sets can help design more efficient computer systems (Arm TechCon'16 and article on machine-learning based optimization) and build accurate models!
Our personal ultimate goal behind CK development is to a) reinvent computer engineering and make it more collaborative, reproducible and reusable, b) develop efficient and reliable computer systems from IoT to supercomputers, c) enable open science via reusable and customizable artifacts, and d) create a public repository of reusable AI artifacts (models, data sets, tools, etc) and portable AI algorithms/workflows (classification, detection, etc). This should help us enable open AI research, boost innovation in science and technology, get back to our AI-related projects, develop artificial brain and have fun ☺!
See ACM ReQuEST-ASPLOS'18 proceedings front matter and our motivation slides:
Introducing the ReQuEST competitions, platform, scoreboard and long-term vision] (ACM ASPLOS'18)
Enabling open and reproducible computer systems research: the good, the bad and the ugly] (CNRS'17)
See how we combine together all above techniques and tools to enable CK-powered open AI research.


In the next step, we will scan the newly created image for issues and known vulnerabilities. We will be using the Jenkins Anchore Image Scanner for this task.
Add the following lines to the Jenkinsfile.
if (BRANCH_NAME ==~ /(develop|release.*)/) {
stage('Container Scan') {
writeFile file: 'anchore_images', text: "${imageBase}/${imageNamespace}/${app_name}:${tag} Dockerfile"
anchore engineRetries: '800', name: 'anchore_images'
}
}
Once complete, you will see the Anchore Report Link associated with the build.


Lightning Talks Overflow @ 35C3
December 29th, 2018
@AlexAltea
Guest and host share the same architecture: However, we need to execute privileged instructions.
Interpreters are too slow.
Recompilers are too slow.
Solution:
Target: We want an hypervisor that is:
...and the winner is Intel HAXM!
Compatible OSs: Linux, Windows, MacOS, NetBSD. Compatible CPUs: Intel (...AMD SVM support planned).
Our contributions
Enough to run the PS4 kernel/userland software!
More at github.com/intel/haxm.
Orbital is based on QEMU, which allows us to:
AM32 CPU running Secure Modules written by Sony.
No publicly known exploitable vulnerabilities:
Essentially a black-box that handles: decryption, encryption, compression, verification, etc.
Question: How can SAMU be emulated *without keys*?
Primary focused on GFX MMIO registers. It describes the pipeline state can be modelled with Vulkan.
CP emulation: Consumes PM4 commands, which can trigger MMIO/memory accesses, draws, among other actions, which are mapped to Vulkan commands.
GCN emulation: GCN shader bytecode can be translated to SPIR-V consumed by the Vulkan drivers.
Marvell Armada SoC (ARM)
104D:908F Aeolia ACPI
104D:909E Aeolia GBE controller
104D:909F Aeolia AHCI
104D:90A0 Aeolia SDHCI
104D:90A1 Aeolia PCI Express glue
104D:90A2 Aeolia DMA controller
104D:90A3 Aeolia Memory (DDR3/SPM)
104D:90A4 Aeolia XHCI USB 3.0 controller
Most of those can be forwarded to QEMU devices.
Interesting is Aeolia PCIe glue device, which exposes registers to communicate with the Aeolia over ICC.
Although would be theoretically possible run the Aeolia software, we are simply high-level emulating it, i.e. reimplementing the handlers for each ICC query.
/mini-syscore.elf
runs successfully./SceSysAvControl.elf
runs successfully./mini-syscore.elf
detects an issue and goes to Safe Mode for recovery (supposed to happen!)./safemode.elf
runs successfully and waits for gamepad input, while submitting draw commands.Discussion at #orbital-emu
@ freenode!
Source at github.com/AlexAltea/orbital
News at twitter.com/AlexAltea
Shout-out to all PS4 devs and Orbital IRC/Discord people!


|
||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
See:
Description
| Interface Summary | |
|---|---|
| KijiContext | Interface for contexts passed to KijiMR methods. |
| KijiTableContext | Context for Kiji bulk-importers or reducers to output to a Kiji table. |
| KVOutputJob | Base interface for tasks that emit (key, value) pairs. |
| Class Summary | |
|---|---|
| DistributedCacheJars | Utility class for dealing with Java JAR files and the hadoop distributed cache. |
| HFileLoader | Loads HFiles generated by a MapReduce job into a Kiji table. |
| KijiMapper<INKEY,INVALUE,OUTKEY,OUTVALUE> | Base class for Kiji mappers. |
| KijiMapReduceJob | A runnable MapReduce job that interacts with Kiji tables. |
| KijiMapReduceJob.Status | The status of a job that was started asynchronously using KijiMapReduceJob.submit() . |
| KijiMapReduceJobBuilder | Builds general MapReduce jobs around Kiji mappers and reducers. |
| KijiReducer<INKEY,INVALUE,OUTKEY,OUTVALUE> | Base class for Kiji reducer. |
| KijiTableReducer<K,V> | Base class for reducers that emit to a Kiji table. |
| MapReduceJobInput | Base class for types of input to a MapReduce job. |
| MapReduceJobOutput | Describe class MapReduceJobOutput here. |
| Exception Summary | |
|---|---|
| JobConfigurationException | Thrown when a MapReduceJob is being built, but it has missing or incomplete configuration. |
KijiMR utilities.
KijiMR includes APIs to build MapReduce jobs that run over Kiji tables, bringing MapReduce-based analytic techniques to a broad base of Kiji Schema users.
KijiMR contains many job builders for various types of MapReduce jobs.
Bulk Importers
- for the creation of bulk
import jobs which allow data to be inserted into Kiji tables efficiently.
Producers
- for the creation of produce jobs
which generate per-row derived entity data.
Gatherers
- for the creation of gather jobs
which scan over the rows of a Kiji table to aggregate information which can be passed to a
reducer.
General MapReduce
- for the creation of
general MapReduce jobs around Kiji mappers and reducers.org.kiji.mapreduce.input
- input formats for MapReduce jobsorg.kiji.mapreduce.output
- output formats for MapReduce jobsorg.kiji.mapreduce.kvstore
- Key-Value store API used in MapReduce jobs
|
||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |


--- layout: example permalink: /examples/content-editable/ exampleId: content-editable stylesheets: - /examples/content-editable/content-editable.css overview: |- This example demonstrates shared rich text editing using a basic content editable element. The example uses the Convergence DOM Utils to create a binding between the content editable element and a Convergence Realtime Model. --- Use typical styling commands (CTRL+B, CTRL+I, etc.)


My final piece is a dispute with the issue of thought and act, showing the process of decision-making through abstract imagery. By using cameraless photography, I eliminated the technical eye and focused on the craft of painting with light and chemical means. Traces of manual labour become visible in the individual pieces and serve as a metaphor for the complex and demanding step to execute an action. Influenced by artists such as Wolfgang Tillmans and Man Ray, I strive to make a work that has potential for triggering empathy and putting a stamp of reality into the more and more digital world we live in.


-- Character Stats --
HP:
/
SPEED:
STRENGTH:
INTELLIGENCE:
--
--
This room has the following exits:
Hey there, welcome to this MUD inspired game.
-- Inventory --


Browse gfactory RRDs
Choose a Glidein destination...
Glidein entry.
Glidein factory status now.
Glidein factory status.
Glidein factory log status.
Glidein factory completed stats.
Glidein factory entry matrix.
Entry
total
Frontend
total
RRD
Status_Attributes
Log_Counts
Log_Completed
Log_Completed_Stats
Log_Completed_WasteTime
Update
Link
Javascript needed for this page to work
RRD file
None
Powered by
RRDTool
,
JavascriptRRD
and
Flot
.


Best Restaurants in {{cityToDisplay.name}}
New Restaurants and Bars in {{cityToDisplay.name}}
Hottest Restaurants and Bars in {{cityToDisplay.name}}
Restaurants and Bars In {{cityToDisplay.name}}
The 10 Best Things We Ate in {{cityToDisplay.name}}
Best Mexican Restaurants in {{cityToDisplay.name}}
Best Burgers in {{cityToDisplay.name}}


Acme Inc
1 Acme House
Acme Way
California
CA1 1AA
United Europe
Date: 01 June 2017
Invoice Number: 5
Purchase Order: PO-1
HMx Labs Limited
Suite H, 31-33 College Road
Harrow
HA1 1EJ
Company Number: 10601521
VAT Number: 264 8043 96
TOTAL
13,800.00
Details
Quantity
Unit
Price
VAT
Rate
Net
Amount
VAT
Gross
Amount
Gadgets
15
800.00
15%
12,000.00
1,800.00
13,800.00
PAYMENT DETAILS
Payment can be made by bank transfer to the account details below. Please ensure you include your invoice number as the payment reference.
Account Name:
HMx Labs Limited
Sort Code:
16 57 10
Account Number:
56410888
Total Net Amount
12,000.00
Total VAT
1,800.00
TOTAL
13,800.00


Gecode::Int::Regular::Dom< View > Class Template Reference
[Integer propagators]
#include <regular.hh>
Inherits Gecode::NaryPropagator< View, PC_INT_DOM >.
Detailed Description
template<class View>
class Gecode::Int::Regular::Dom< View >
Domain-consistent regular propagator.
The algorithm for the regular propagator is based on: Gilles Pesant, A Regular Language Membership Constraint for Finite Sequences of Variables, CP 2004. Pages 482-495, LNCS 3258, Springer-Verlag, 2004.
Requires
#include "gecode/int/regular.hh"
Definition at line 46 of file regular.hh.
Public Member Functions | |
| virtual Actor * | copy (Space *home, bool share) |
| Copy propagator during cloning. | |
| virtual PropCost | cost (void) const |
| Cost function (defined as dynamic PC_LINEAR_HI). | |
| virtual ExecStatus | propagate (Space *home) |
| Perform propagation. | |
| virtual void | flush (void) |
| Flush layered graph. | |
| virtual size_t | size (void) const |
| Returns size of layered graph. | |
| virtual size_t | dispose (Space *home) |
| Delete propagator and return its size. | |
Static Public Member Functions | |
| static ExecStatus | post (Space *home, ViewArray< View > &x, DFA &d) |
| Post propagator on views x and DFA d. | |
Protected Member Functions | |
| Dom (Space *home, bool shared, Dom< View > &p) | |
| Constructor for cloning p (use shared for dfa). | |
| Dom (Space *home, ViewArray< View > &x, DFA &d) | |
| Constructor for posting. | |
Protected Attributes | |
| DFA | dfa |
| The DFA describing the language. | |
| LayeredGraph * | lg |
| Propagation is performed on a layered graph (used as cache). | |
Classes | |
| class | LayeredGraph |
| LayeredGraph as data structure used for propagation in regular More... |
Constructor & Destructor Documentation
|
|
Constructor for cloning p (use shared for dfa).
|
|
|
Constructor for posting.
|
Member Function Documentation
|
|
Copy propagator during cloning.
Implements Gecode::Actor. |
|
|
Cost function (defined as dynamic PC_LINEAR_HI).
Reimplemented from Gecode::NaryPropagator< View, PC_INT_DOM >. |
|
|
Perform propagation.
Implements Gecode::Propagator. |
|
|
Flush layered graph.
Reimplemented from Gecode::Actor. |
|
|
Returns size of layered graph.
|
|
|
Delete propagator and return its size.
Reimplemented from Gecode::NaryPropagator< View, PC_INT_DOM >. |
|
|
Post propagator on views x and DFA d.
|
Member Data Documentation
|
|
The DFA describing the language.
Definition at line 49 of file regular.hh. |
|
|
Propagation is performed on a layered graph (used as cache).
Definition at line 51 of file regular.hh. |
The documentation for this class was generated from the following files:
- gecode/int/regular.hh (Revision: 3512)
- gecode/int/regular/dom.icc (Revision: 3512)


Adding a new account will give the user access to another service.
After creating the account, set the user's password so that they can log in.


I'm working on a new project, The Minitest Cookbook, that will teach you to turn little ol' Minitest into a lean, mean, fully-customized testing toolchain. Sign up below to receive updates.


Amazing, as is the case with everyone else it was easy to make an app even though I came from web dev background. Documentation and forum are amazing as well.
FB login integration was a challenge, I tried a plugin(oauth.io) previously which would ask the user to login even if he is already logged in through FB device. We scrapped it and used wizcorps plugin which is awesome.
Before implementing anything look for existing ionic apps which have similar feature and have good performance, look into its code(ionic related design aspects) and start from there. It can save a lot of time.
3 Million Downloads
Featured in Apple App Store & Google Play
Android Drawer
HTML5 Inline Video
13 Languages
Healthkit, HTML5Video, SessionM, Kiip, LowLatencyAudio, SocialShare, Datepicker, ScreenOrientation, AppAvailability, Keyboard, File, File-Transfer, Splashscreen, InAppBrowser


My First Post!
Hello, My Name Is Kim Marberry. I started an Internship eight weeks ago to learn about cloud computing. I went into this endeavor with very little knowledge of actually running and setting up cloud servers. In school we used Azure for our Capstone but did not delve into really what that service was building. When I got to Nutech they put me to work on researching the differences between two main opensource cloud computing services, OpenStack and Cloudstack.
Written on August 1, 2016


Top Chart
Reset Filters
Brands
adidas
nike
puma
Collection
dfsdfd
Model
sdfs
Price Bands
sdfs
BreadCrumbs
Football Boots - The Best In The Market
Previous Page
Page
1
/ 60
Next Page
adidas
COPA
New
Them Boots
Price:
$200
adidas
COPA
Exclusive
Them Boots
Price:
$200
adidas
COPA
Them Boots
Price:
$200
adidas
COPA
Them Boots
Price:
$200