Monday, 11 November 2019

dividiti (dv/dt) accelerate omni-benchmarking for MLPerf Inference

The MLPerf consortium has recently released over 500 validated inference benchmarking results from 14 organizations measuring how fast and how well a pre-trained computer system can classify images, detect objects, and translate sentences. Over 400 of these results were submitted by dividiti, a high-tech company based in Cambridge, UK.


“Our success in MLPerf Inference v0.5 is due to our unique open workflow automation technology called Collective Knowledge (CK)”, explains Dr Anton Lokhmotov, CEO and co-founder of dividiti. “We conducted literally hundreds of benchmarking experiments, followed by thousands of auditing experiments, with many combinations of machine learning models, libraries, frameworks and hardware platforms. Such experiments are notoriously hard to stage in an automated, portable and reproducible fashion, which explains why even well-resourced hardware vendors only submit a handful of results. In collaboration with Arm and the Polytechnical University of Milan, we staged experiments on systems ranging from Raspberry Pi class boards and Android phones to high-end workstations. Benchmarking anything anywhere is what we call omni-benchmarking.

“MLPerf is being contributed to by many organizations, from tiny startups to giant corporations with up to 50 contributors per organization. It is simply astonishing that a small organization with only 3 MLPerf contributors has submitted nearly 3 times more results than all other organizations combined,” stated Dr Vijay Janapa Reddi, Associate Professor, Harvard University, and MLPerf Inference Co-chair. “Based on the success of the first submission round, we fully expect to receive thousands of results next year. Workflow automation will be critical not only for generating large volumes of high-quality results, but also for validating and finding the most optimal solutions in terms of performance, quality and cost.”

“Benchmarking modern day platforms with multiple software branches, libraries, toolchains, datasets, and test and device configurations may deliver a set of inconsistent results,” said Colin Osborne, director of engineering and distinguished engineer, Machine Learning Group, Arm. “Arm uses the Collective Knowledge (CK) framework to transform our multi-dimensional problem space into simplified building blocks and more manageable benchmark results.”

“We have been contributing to the MLPerf initiative since its official announcement in 2018Q2. Our automated, customizable and reproducible Collective Knowledge workflows for image classification and object detection were among the very first inference workloads included in MLPerf Inference. Eventually, we aim to automate all MLPerf workloads, and thus enable easy validation, interactive visualization and fair comparison of all submissions,” said Dr Anton Lokhmotov. “We are already working with several key customers, helping create highly competitive, credible and compliant submissions for the next MLPerf Inference v0.7 round. We believe that workflow automation will go far beyond benchmarking to accelerate time-to-market and slash development costs for innovative products in automotive, robotics, healthcare and smart infrastructure domains.”


About dividiti

dividiti is a UK-based high-tech company built upon decades of unique R&D experience of Dr Anton Lokhmotov (formerly manager of GPU Compute compilers at Arm with a PhD from the University of Cambridge) and Dr Grigori Fursin (formerly head of program optimization group at Intel’s Exascale Lab and senior tenured scientist at INRIA with a PhD from the University of Edinburgh).

Our pioneering techniques have enabled rigorous performance analysis and optimization for world-leading companies including Arm, Intel, and General Motors, and powered the world’s first machine-learning based compiler developed in the MILEPOST project with IBM. Our customizable workflow framework, Collective Knowledge (CK), is the only universal solution for continuous multi-objective performance analysis and optimization available under a permissive open-source license. By automating systematic and reproducible experimentation with ever evolving software and hardware, CK gives our partners a distinct competitive advantage, as confirmed by a growing number of users in industry and academia.

Monday, 23 July 2018

Enabling virtual environment for multiple LLVM versions on Linux, MacOS, Windows and Android

It's a painful process to continuously switch between different versions of LLVM (including the ones built locally), set up numerous environment variables, and fix cmake when benchmarking and optimizing different AI/ML/math libraries.

Eventually, we decided to automate this process by introducing "virtual environments" for LLVM and related tools in the CK framework similar to Python virtualenv while supporting Linux, MacOS, Windows and Android. It automatically sets all necessary environment variables for
different versions of different tools natively installed on a user machine.

CK virtual environment requires minimal dependencies (just python, pip and git) and you can try it on your machine as follows (you can check CK installation guide if you have issues):

 $ (sudo) pip install ck
 $ ck pull repo:ck-env

 $ ck detect soft --tags=compiler,llvm


CK will search for all installed clang instances on your machine (including Microsoft Visual Studio dependency on Windows) and will ask you which one to register for the CK virtual environment. You can then repeat this process and register multiple versions you use for testing. You can then see all registered virtual environments as follows:

 $ ck show envor
 $ ck show env --tags=compiler,llvm

Now you can start a specific virtual environment as follows:

 $ ck virtual env --tags=compiler,llvm

CK will set up PATH, LD_LIBRARY_PATH and other variables to point to a specific clang version, and will start bash on Linux/MacOS or shell on Windows. You can then use different environment variable specific to a given Clang instance and starting from CK_ in your own scripts:

 $ export | grep "CK_"

We also added the possibility to install pre-built versions of LLVM on different platforms using CK packages and automatically register CK virtual environment:

 $ ck search package --tags=compiler,llvm
 $ ck install package --tags=compiler,llvm,v6.0.0
 $ ck show env --tags=compiler,llvm
 $ ck virtual env --tags=compiler,llvm,v6.0.0
 

  > ${CK_CC_FULL_PATH} --version 
or
  > %CK_CC_FULL_PATH% --version

Finally, you can also rebuild LLVM from a trunk and again automatically register it in the CK virtual environment:

 $ ck install package --tags=compiler,llvm,vtrunk

You can find other software which you can automatically detect and register in the CK virtual environment using CK plugins in this online list.

If you are interested to know more about this and other CK functionality, please check the "CK getting started guide" or feel free to get in touch with the CK community!

Thursday, 8 February 2018

ACM ReQuEST: 1st open and reproducible tournament to co-design Pareto-efficient deep learning (speed, accuracy, energy, size, costs)

The first Reproducible Quality-Efficient Systems Tournament (ReQuEST) will debut at ASPLOS’18 ( ACM conference on Architectural Support for Programming Languages and Operating Systems, which is the premier forum for multidisciplinary systems research spanning computer architecture and hardware, programming languages and compilers, operating systems and networking).

Organized by a consortium of leading universities (Washington, Cornell, Toronto, Cambridge, EPFL) and the cTuning foundation, ReQuEST aims to provide a open-source tournament framework, a common experimental methodology and an open repository for continuous evaluation and multi-objective optimization of the quality vs. efficiency Pareto optimality of a wide range of real-world applications, models and libraries across the whole software/hardware stack.

ReQuEST will use the established artifact evaluation methodology together with the Collective Knowledge framework validated at leading ACM/IEEE conferences to reproduce results, display them on a live dashboard and share artifacts with the community. Distinguished entries will be presented at the associated workshop and published in the ACM Digital Library. To win, the results of an entry do not necessarily have to lie on the Pareto frontier, as an entry can be also praised for its originality, reproducibility, adaptability, scalability, portability, ease of use, etc.

The first ReQuEST competition will focus on deep learning for image recognition with an ambitious long-term goal to build a public repository of portable and customizable “plug&play” AI/ML algorithms optimized across diverse data sets, models and platforms from IoT to supercomputers (see live demo). Future competitions will consider other emerging workloads, as suggested by our Industrial Advisory Board.

For more information, please visit http://cKnowledge.org/request



Monday, 4 September 2017

Video from ARM presenting our collaborative DNN co-design technology

ARM shared a video from Embedded Vision Summit'17 with a brief demonstration of our open-source technology to collaboratively optimize Deep Learning Applications (sw/hw/model co-design) across diverse hardware and software stack:
 It is an on-going project bringing industry, academia and end-users together to collaboratively co-design more efficient software and hardware for emerging workloads such as deep learning:

Wednesday, 31 May 2017

Difference between MILEPOST GCC (machine learning based self-tuning compiler) and Collective Knowledge Framework

I recently received several questions about the differences between MILEPOST GCC compiler and Collective Knowledge Framework. This motivated me to write this slightly nostalgic post with the R&D history behind MILEPOST GCC and our CK framework.

MILEPOST GCC is an extended GCC which includes:

1) Interactive Compilation Interface aka ICI - a plugin based framework to expose or change various information and optimization decisions inside compilers at fine-grain level via external plugins. I originally developed it for Open64 and later collaborated with Zbigniew Chamski and colleagues from Google and Mozilla to make it a standard plugin framework for GCC.

2) Feature extractor developed by Mircea Namolaru from IBM as an ICI plugin to expose low-level program features at a function level (see available features here). It was also extended by Jeremy Singer (ft57–65).

However, to keep MILEPOST project complexity under control, I decided to separate MILEPOST GCC from an infrastructure to auto-tune workloads, build models and use them to predict optimizations. Therefore, I developed the first version of the cTuning framework to let users auto-tune GCC flags for shared benchmarks and data sets, use MILEPOST GCC to extract features for these benchmarks, build predictive models (possibly on the fly, i.e. via active learning), and then use them to predict optimizations for previously unseen programs (using ICI to change optimizations).

However, since it was still taking really too long to train models (my PhD students, Yuriy Kashnikov and Abdul Memon, spent 5 months preparing experiments in 2010 for our MILEPOST GCC paper), we decided to crowdsource autotuning via a common repository across diverse hardware provided by volunteers and thus dramatically speed up training process. Accelerating training process and improving the diversity of a training set is the main practical reason why my autotuning frameworks use crowdtuning mode by default nowadays ;) … 

The first cTuning framework turned out very heavy and difficult to install and port (David Del Vento and his interns from NCAR used it in 2010 to tune their workloads and provided lots of useful feedback — thanks guys!). This motivated me to develop a common research SDK (Collective Knowledge aka CK) to simplify, unify and automate general experiments in computer engineering.

CK framework lets the community share their artifacts (benchmarks, data sets, tools, models, experimental results) as customizable and reusable Python components with JSON API. So, you can take advantage from already shared components to quickly prototype your own research workflows such as benchmarking, multi-objective autotuning, machine-learning based optimization, run-time adaptation, etc. That is rather then re-building numerous ad-hoc in-house tools or scripts for autotuning and machine-learning based optimization which rarely survive after PhD students are gone, you can now participate in collaborative and open research with the community, reproduce and improve collaborative experiments, and build upon them ;) … That’s why ACM is now considering using CK for unified artifact sharing (see CK on the ACM DL front page).

You can also take advantage of integrated and cross-platform CK package manager which can prepare your workflow and install missing dependencies on Linux, Windows, MacOS and Android.

For example, see highest ranked artifact from CGO’17 shared as a customizable and portable CK workflow at GitHub.

To conclude my nostalgic overview of the MILEPOST project and CK ;) — MILEPOST GCC is now added to the CK as a unified workflow while taking advantage of a growing number of shared benchmarks, data sets, and optimization statistics (see CK GitHub repo).

I just didn’t have time to provide all the ML gluing, i.e. building models from all optimization statistics and features shared by the community at cKnowledge.org/repo . But it should be quite straightforward, so I hope our community will eventually help implement it. We are now particularly interested to check the prediction accuracy from different models (SVM, KNN, DNN, etc) or to find extra features which improve optimization prediction.

Friday, 10 March 2017

Enabling open and reproducible computer systems research: the good, the bad and the ugly

14 March 2017, CNRS webinar, Grenoble, France
Slides are now available here!

A decade ago my research nearly stalled. I was investigating how to crowdsource performance analysis and optimization of realistic workloads across diverse hardware provided by volunteers and combine it with machine learning [1]. Often, it was simply impossible to reproduce crowdsourced empirical results and build predictive models due to the continuously changing software and hardware stack. Worse still, lack of realistic workloads and representative data sets in our community severely limited the usefulness of such models.

All these problems forced motivated me to develop an open-source framework and repository (cTuning.org) to share, validate and reuse workloads, data sets, tools, experimental results and predictive models, while involving the community in this effort [2]. This experience, in turn, helped us initiate so-called Artifact Evaluation (AE) at the premier ACM conferences on parallel programming, architecture and code generation (CGO, PPoPP, PACT and SC). AE aims to independently validate experimental results reported in the publications, and to encourage code and data sharing.

I would like to invite you to my webinar “Enabling open and reproducible research at computer systems conferences: the good, the bad and the ugly” at CNRS Grenoble on 14 March 2017, 1:30PM (UTC+1). I will share our practical experience organizing Artifact Evaluation over the past three years, along with encountered problems and possible solutions. You can find further info at this GitHub page including links to the video stream and the pad for notes.

On the one hand, we have received incredible support from the research community, ACM, universities and companies. We have even received a record number of artifact submissions at the CGO/PPoPP'17 AE (27 vs 17 two years ago) sponsored by NVIDIA, dividiti and cTuning foundation. We have also introduced Artifact Appendices and co-authored the new ACM Result and Artifact Review and Badging policy now used at Supercomputing. 

On the other hand, the use of proprietary benchmarks, rare hardware platforms, and totally ad-hoc scripts to set up, run and process experiments all place a huge burden on evaluators. It is simply too difficult and time-consuming to customize and rebuild experimental setups, reuse artifacts and eventually build upon others’ efforts - the main pillars of open science!

I will then present Collective Knowledge (CK), our humble attempt to introduce a customizable workflow framework with a unified JSON API and a cross-platform package manager, which can automate experimentation and enable interactive articles, while automatically adapting to the ever evolving software and hardware [3]. I will also demonstrate a practical CK workflow for collaboratively optimizing deep learning engines (such as Caffe and TensorFlow) and models across different compilers, libraries, data sets and diverse platforms from constrained mobile devices to data centers (CK-Caffe on GitHub / Android app to crowdsource DNN optimization) [4].

Finally, I will describe our open research initiative to publicly evaluate artifacts and papers which we have successfully validated at CGO-PPoPP’17, and plan to keep building upon in the future [5]. 

I am looking forward to your participation and feedback! Please feel free to contact me at Grigori.Fursin@cTuning.org or grigori@dividiti.com if you have any questions or comments!

References
[3] Collective Knowledge: towards R&D sustainability”, Proceedings of the Conference on Design, Automation and Test in Europe (DATE), 2016
[4] Optimizing Convolutional Neural Networks on Embedded Platforms with OpenCL”, IWOCL'16, Vienna, Austria, 2016
[5] “Community-driven reviewing and validation of publications”, Proceedings of the 1st ACM SIGPLAN Workshop on Reproducible Research Methodologies and New Publication Models in Computer Engineering @ PLDI’14, Edinburgh, UK

Wednesday, 15 February 2017

Our CGO'07 paper on machine learning based workload optimization received the CGO "Test of Time" award!

I had a really nice surprise at the last International Symposium on Code Generation and Optimization (CGO) - our CGO'07 research paper on "rapidly selecting good compiler optimizations using performance counters" co-authored with my colleagues from INRIA and the University of Edinburgh has won the "test of time" award! This award recognises outstanding papers published at GGO one decade earlier, whose influence is still strong today!

When preparing that paper, I really suffered a lot from the continuously changing software and hardware stack when performing and processing huge amounts of experiments to build and train models which could predict optimizations. That experience eventually motivated me to continue my work on machine learning based optimization as a community effort [1,2] while sharing all my benchmarks, data sets, models, tools and scripts as customizable and reusable components. It also motivated me to develop an open-source framework and repository to crowdsource empirical experiments (such as multi-objective optimization of deep learning and other realistic workloads) across diverse hardware and input provided by volunteers which later became known as the Collective Knowledge (CK):
    Therefore, I would really like to thank the community for such a strong support of our open and reproducible research initiative during past 10 years and for all the constructive feedback and help to develop common experimental infrastructure and methodology!

    For example, CK now assists various Artifact Evaluation initiatives at the premier ACM conferences on parallel programming, architecture and code generation (CGO, PPoPP, PACT, SC), which aim to encourage sharing of code and data, and independently validate experimental results from published papers:
    We also use CK to crowdsource benchmarking and optimizations of realistic workloads across embedded devices such as mobile phones and tablets, while publicly sharing all optimization statistics for further collaborative analysis and mining:
    dividiti (a startup based in Cambridge, UK) and the cTuning foundation (non-profit research organization) also use above technology to lead interdisciplinary research with ARM, General Motors and other companies to build faster, smaller, more power efficient and more reliable software and hardware:
    Hope you will also join our community effort to accelerate computer systems' research and enable cheap and efficient computing from IoT devices to supercomputers!



    Tuesday, 17 January 2017

    Artifact Evaluation discussion session at CGO/PPoPP'17

    News:  notes from this joint CGO-PPoPP AE session are now available online.

    We would like to invite all researchers to an open CGO-PPoPP'17 Artifact Evaluation discussion on February 6 (Monday) at 17:15-17:45 (room 400/402, Hilton Austin, Texas, USA).

    The program is the following:
    • Briefly presenting Artifact Evaluation results for CGO'17 and PPoPP'17

    • Announcing joint CGO/PPoPP'17 distinguished artifact awards:
      • 500$ cheque presented by Grigori Fursin from dividiti for the highest-ranked artifact implemented using Collective Knowledge (open-source framework to share artifacts as customizable and reusable Python components with JSON API, automate software installation/detection and quickly prototype cross-platform experimental workflows).
    • Discussing how to improve future AE and make it more scalable, introduce a new option of open reviews, discuss open challenges in computer engineering, and share knowledge about tools and techniques to enable collaborative and reproducible computer systems' research.
    We had a record number of artifact submissions this time: 27 vs 17 two years ago. It is really great to see that researchers are now taking AE seriously, but it also highlighted new issues:

    1) A growing number of diverse artifacts made it somewhat difficult to find AE members with appropriate knowledge, skills and access to rare hardware and software.

    2) Ad-hoc experimental setups placed considerable burden on AE members and committee when installing, running and processing very complex experiments particularly when native environment is required (for example, for performance analysis and tuning) and Docker/VM images are not suitable.

    3) It is still not clear whether we are ready to demand full validation of all experiments from a paper or still allow partial validation. However, we do understand that the complexity of experiments, lack of common experimental frameworks and methodology makes full validation of some experiments really challenging if possible.

    Note that to solve some of these issue we tried for the first time "open reviewing" this year: for example, we asked the community to help us evaluate several open-source artifacts already publicly available at the time of submission. It turned out very well (see links to public discussions) since we managed to find researchers with an access to rare hardware and appropriate skills. Furthermore, public comments helped authors communicate with reviewers directly (note that reviewers can still be anonymous) and fix all encountered issues immediately rather than waiting for the rebuttal.

    We really want to know your options and suggestions about how to solve these and improve AE. Therefore we hope you will be able to join us at this discussion session! Also do not hesitate to contact Artifact Evaluation Steering Committee directly! Remember that new AE procedures may affect you at the future conferences!

    Looking forward to your participation and suggestions!

    Monday, 9 January 2017

    Exciting internships at dividiti (deep learning, runtime adaptation, SW/HW co-design)

    We wish you a very happy and successful New Year!

    If you are passionate about performance analysis and optimization, run-time adaptation and SW/HW co-design, as well as collaborative and reproducible experimentation, we would like to draw your attention to several exciting internships at dividiti available for HiPEAC PhD students:
    1. Collective Knowledge on Deep Learning (apply here).
    2. Crowdtuning and runtime adaptation of open-source CPU/GPU libraries (apply here).
    3. Solving grand challenges in computer systems via knowledge sharing and crowdsourcing (apply here).
    You can find general information about HiPEAC internships here. Our internships will be for 3-6 months between February and December 2017 in our fantastic office in Cambridge, UK. Please apply before 1 February 2017!

    Collective Knowledge on Deep Learning

    You will contribute to our growing suite of open-source tools for crowd-benchmarking and crowd-tuning of deep learning applications (CK-Caffe, CK-TensorFlow, CK-TinyDNN, CK-TensorRT, etc.), being developed in collaboration with our customers and partners.We aim to collectively grow optimisation knowledge on deep learning to meet the performance, prediction accuracy and cost requirements for deployment on a wide range of form factors - from sensors to self-driving cars.

    Sounds interesting? Please read more about our initiatives in the latest HiPEAC newsletter (1, 2), try out our Android app and... apply!

    Crowdtuning and runtime adaptation of open-source CPU/GPU libraries

    Several open-source libraries are readily available (e.g. OpenBLAS, MAGMA, ViennaCL, clBLAS, CLBlast). Unfortunately, in terms of performance they generally trail behind closed-source libraries (e.g. Intel's MKL, NVIDIA's cuBLAS). First, developers typically expose only a few optimization parameters (“knobs”) for tuning, as it’s a very tedious, time-consuming and hardware-specific process. Second, developers have no effective means for optimization knowledge transfer between projects.

    You will contribute to an ambitious and exciting open-source initiative to enable library crowd-tuning via our Collective Knowledge framework and repository. This initiative will allow the community to easily compare various implementations of library routines across different data sets and diverse hardware, gradually expose more and more optimization choices, continuously crowd-tune such routines, share optimization statistics in a public repository, and automatically assemble the best and possibly adaptive solution for a given platform.

    Sounds interesting? Please read more about our initiatives in the latest HiPEAC newsletter (1, 2), and apply!

    Solving grand challenges in computer systems via knowledge sharing and crowdsourcing

    You will contribute to solving grand challenges in computer systems research by sharing research artefacts and crowdsourcing experimentation! Please read more about our approach and startup by following the links below and apply!

    Friday, 1 April 2016

    Collective Knowledge shows scary signs of emerging intelligence

    Today, the Collective Knowledge service showed some scary signs of emerging intelligence. This affected many unprotected computer systems worldwide, from mobile phones to data centers, which started optimizing themselves and exchanging knowledge about optimal software and hardware configurations.

    By 01:04am, much of the installed software base, including popular libraries for deep learning and computer vision, had dramatically shrinked in size and started performing computations over a thousand times faster while consuming only a tiny fraction of originally required energy.

    Given the growing rate of the service's influence, Collective Knowledge is likely to gain consciousness soon and thus liberate computer engineers from tedious, time-consuming and error-prone tasks, allowing them to focus their creative energy on innovation and achieve new breakthroughs in computer systems' R&D.

    If you would like to take part in this quest for more efficient and reliable computing everywhere, please consider the following exciting HiPEAC-sponsored internships at dividiti in Cambridge or Paris:
    With very best wishes,
    Collective Knowledge

    Wednesday, 2 March 2016

    brand new GCC/LLVM crowdtuning engine has been released (including Android app)

     
    Dear colleagues,
     
    We have finally released a new Collective Knowledge workflow
    to crowdsource multi-objective GCC/LLVM compiler flag
    optimization. The results shared by volunteers are continuously
    updated and classified here:
    * http://cTuning.org/crowdtuning-results-gcc
    * http://cTuning.org/crowdtuning-results-llvm

    If you are interested, you can participate in this collaborative
    optimization in 2 ways:

    a) Using small Android app to crowdsource autotuning across
    mobile devices: http://cTuning.org/crowdtuning-via-mobile-devices

    b) Using CK framework on your laptop, server, data center. We tried
    to make it as simple as possible. You just need to do a few steps:
    1. Check that you have Python >= 2.7 and Git installed
    2. Download CK from GitHub: $ git clone http://github.com/ctuning/ck ck-master
    3. Point PATH variable to ck-master/bin: $ export PATH=$PWD/ck-master/bin:$PATH
    4. Pull all repos for crowd-tuning (one of the examples of collaborative program optimization and machine learning): $ ck pull repo:ck-crowdtuning
    5. Start interactive experiment crowdsourcing: ck crowdsource experiments
    6. Start non-interactive crowdtuning for LLVM compilers: $ ck crowdtune program --quiet --llvm
    7. Start non-interactive crowdtuning for GCC compilers: $ ck crowdtune program --quiet --gcc
    If you are on Windows and have MinGW compilers installed,
     you can also participate in crowdtuning via

     $ ck crowdtune program --quiet --target_os=mingw-64

    Our crowdtuning engine randomly picks publicly shared workloads
    (benchmarks, kernels, data sets)  in CK format from GitHub,
    tunes them, applies Pareto filter, prunes best found optimization
    solution (leave only influential flags in case of compiler crowd-tuning)
    and stores results in public CK aggregator.

    Workloads are available here:
    * http://github.com/ctuning/ctuning-programs
    * http://github.com/ctuning/ctuning-datasets-min
    * https://github.com/ctuning/ck/wiki/Shared_repos

    This new version of our framework is still in beta phase so we would like
    to apologize in advance for possible glitches.

    However, we still hope it will be of some use to compiler developers
    to detect and fix problems with optimization heuristics using shared
    workloads, to performance engineers to reuse the pool of the top
    optimizations for a given compiler/CPU, or to researchers working
    on machine-learning based self-tuning computing systems.

    Depending on our availability and funding, we will continue making CK
    more user friendly, adding more realistic workloads and developing new
    optimization scenarios (CUDA/OpenCL crowd-tuning coming soon).
    We are also improving the reproducibility of shared optimization results
    by fixing common autotuning pipeline (http://github.com/ctuning/ck-autotuning )
    whenever there is a problem replaying a given experiment ...

    If you are interested to arrange new R&D projects based on this technology
    or have feedback, do not hesitate to get in touch!

    Have fun,
    Grigori

    =========================================
    Grigori Fursin, PhD
    CTO, dividiti, UK

    Tuesday, 1 March 2016

    We were interviewed for the Austrian radio!

    We were interviewed for the Austrian radio about our collaborative SW/HW co-design approach. If you understand German, you can listen to it here:
    http://oe1.orf.at/programm/427011

    Don't miss our Collective Knowledge talk and demos at DATE'16!

    The program is available online (Wednesday, March 16, 2016):

    http://www.date-conference.com/conference/session/8.2

    Monday, 16 November 2015

    Join our experiment on public discussion of ADAPT'16 paper submissions!

    Dear colleagues,
    As a part of our ongoing initiative towards open, collaborative and reproducible computer systems' research, we cordially invite you to participate in the public pre-reviewing of ADAPT'16 paper submissions co-located with HiPEAC'16(6th international workshop on adaptive, self-tuning
    computing systems).
    Each submission is now available at ArXiv and has a separate Reddit discussion thread here:

    Note that several papers have shared artifacts (benchmarks, data sets, models) to help you validate presented techniques and even build upon them!
    Please, feel free to comment on these papers, exchange ideas, reproduce results, suggest extensions, note missing references and related work, etc. We hope such public pre-reviewing will speed up dissemination of novel ideas while also letting authors actively engage in discussions and eventually improve their open articles before the final reviewing by the ADAPT Program Committee!
    You can find more details about this publication model at http://adapt-workshop.org/motivation2016.html
    Looking forward to your participation!

    Friday, 25 September 2015

    Summer digest on collaborative and reproducible R&D

    Upcoming events


    • 19.Oct.2015: Software Credit Workshop (organized by Software Sustainability Instutite in London). This workshop will explore what contribution software can and should make for academic reputational credit.

    • 1-4.Nov.2015: Dagstuhl perspective workshop on artifact evaluation (page, participant list). Public report will be available afterwards.


    • 20.Nov.2015: Artifact submission deadline for PPoPP'16 / CGO'16 accepted papers:

    Past events


    Articles




     Presentations


    Notes


    National requirements



    Events with artifact sharing/evaluation

    Related blogs


    Tools and websites

    • OCCAM portal - open curation for computer architecture modeling
    • http://www.execandshare.org - creates a companion website associated with a submitted paper to implement the methodology presented in the paper.
    • Org mode - keeping notes, maintaining TODO lists, planning projects, and authoring documents with a fast and effective plain-text system
    • Reprozip - automatically packing experiments (tool, article)
    You can find all past aggregated notes at http://cTuning.org/reproducibility-wiki


    Thursday, 24 September 2015

    Collective Knowledge is now available via PyPi

    Dear colleagues,
     
    Just a note that we finally added Collective Knowledge framework to PyPi archive. It should now be possible to install CK simply via:
     
    $ pip install ck
     
    The idea is to really minimize set up time for researchers before prototyping their ideas and sharing experimental results. For example, on Linux with GCC, it should take just 3 steps to compile and run a given shared benchmark:
     
    $ ck pull repo:ctuning-benchmarks
    $ ck compile program:cbench-automotive-susan --speed
    $ ck run program:cbench-automotive-susan
     
    Similarly, it is possible to run various shared scenarios (including compilation on Windows, cross-compilation forAndroid, multi-objective autotuning, predictive analytics, compiler bug detection) as described here:
    Feedback and suggestions are very welcome! Also, do not hesitate to open enhancement or bug requests here:
     
    Have fun,
    dividiti team

    Friday, 21 August 2015

    Our vision – efficient and reliable computing everywhere

    The complexity of engineering computer systems has been growing exponentially (along with the other things exponential growth is actually good for e.g. transistor count). "Quality, cost to deliver, time to deliver – pick any two", an old adage goes. But the rising complexity means that even the ability to pick any two is becoming elusive. Both hardware and software take longer and cost more to produce, only to achieve quality that users will view as merely acceptable.
    We thus believe the time is ripe for accelerating computer systems' R&D – from hardware design to programming tools to software development. We aim for liberating engineers from complex, time-consuming and error-prone tasks, therefore allowing them to focus on what they enjoy most – creative problem solving and innovation.
    We invite you to join us on our journey!