\documentclass[hyperref={pdfpagelabels=false}]{beamer}

\setbeameroption{show notes}

\mode<presentation>
{
  %\useinnertheme{echt}
  %\useinnertheme{proef}
  \usetheme{recore}
  \setbeamercovered{transparent}
%\setbeamertemplate{footline}[frame number]
}

\usepackage[english]{babel}
\usepackage[latin1]{inputenc}
\usepackage{times}
\usepackage[T1]{fontenc}
\usepackage{acronym}
\usepackage{tikz}
\usepackage{multimedia}
\usepackage{subfigure}
\usepackage{booktabs}
% Can use a tiny fontsize
\usepackage{fancyvrb}


%\usepackage{pgfpages}
%\pgfpagesuselayout{4 on 1}[a4paper,border shrink=5mm]

%For handouts, use the following two lines:
%\usepackage{pgfpages}
%\pgfpagesuselayout{2 on 1}[a4paper,border shrink=5mm]


\title
{MontiumC Transforming}

\author {Matthijs Kooijman}

\institute[Recore Systems and University of Twente]
{
  \inst{}%
  Recore Systems
  \and
  \inst{}%
  Faculty of Electrical Engineering, Mathematics and Computer Science\\
  University of Twente
  }
  
\begin{document}

\begin{frame}
	\titlepage
\end{frame}

\begin{frame}{Contents}
  \tableofcontents
\end{frame}

\section{Introduction}
  \begin{frame}{Montium Tile Processor}
    \begin{itemize}
      \item Explicitely parallel processor
      \item Multilevel reconfiguration
      \item Separate memory addressing units
      \item Data oriented, limited control flow
      \item Redesign on the way
    \end{itemize}
  \end{frame}

  \begin{frame}{MontiumC}
    \begin{itemize}
      \item Subset of C
      \item Operations on data using MontiumC API
      \item Compilable by gcc (as C++)
      \item Under constant improvement
    \end{itemize}
  \end{frame}

  \begin{frame}{Low Level Virtual Machine (LLVM)}
    \begin{itemize}
      \item Compiler framework.
      \item Provides:
      \begin{itemize}
        \item C Frontend
        \item Intermediate representation (LLVM IR)
        \item Transformation passes
        \item Native codegenerators
        \item JIT compilation
      \end{itemize}
      \item Very modular
    \end{itemize}
  \end{frame}

  \begin{frame}{Compiling MontiumC}
    \pgfdeclareimage[width=\textwidth]{Compiling}{images/Compiling}
    \pgfuseimage{Compiling}
    \begin{itemize}
      \item Focus: montiumccfe and transformations
    \end{itemize}
  \end{frame}

\section{Tasks}

  \subsection{Original tasks}
    \begin{frame}{Original tasks}
      \begin{itemize}
        \item Select LLVM transformations
        \item Improve and add transformations
        \item Provide debugging information
      \end{itemize}
    \end{frame}

  \subsection{Extra tasks}
    \begin{frame}{Extra tasks}
      \begin{itemize}
        \item What is MontiumC?
        \item What is Montium IR?
        \item Reconfigurable binaries
      \end{itemize}
    \end{frame}

    \begin{frame}{What is MontiumC?}
      \note{Two angles: What do we want, and what do we support.}
      \begin{itemize}
      \item Status: Specification is ongoing
      \item Challenges:
        \begin{itemize}
          \item Clang is nontransparent
          \note[item]{Clang --- A lot of special cases}
          \item C is complex
          \note[item]{Complex C --- A lot of corner cases}
          \item C is limited
          \note[item]{Limited C --- Need to use annotations, limited amount of types}
          \item Assembly vs. High level
          \note[item]{Tradeoffs -- Code size vs compiler complexity, clarity
          vs control, clarity vs determinism}
        \end{itemize}
      \end{itemize}
    \end{frame}

    \begin{frame}[containsverbatim]
      \begin{columns}
        \begin{column}{0.5\textwidth}
          Low level
          \begin{Verbatim}[fontsize=\tiny]
mem input;
mem output;
word factor;

void run(void) {
  factor = from_int(2);
  input  = alloc_mem(P0M0);
  output = alloc_mem(P0M1);
  set_base(input, 0);
  set_offset(input, 0);
  set_base(output, -1);
  set_offset(output, -1);

  next_cycle();
  word in = read_mem(input);
  word out = p0o0(imul(ra1(in), rc1(factor)))
  add_offset(input, 1);
  add_offset(output, 1);
  init_loop(LC1, 8);
  do {
    write_mem(output, out);
    in = read_mem(input);
    out = p0m0(imul(ra1(in), rc1(factor)))
    add_offset(input, 1);
    add_offset(output, 1);
  } while(loop_next(LC1));

  write_mem(output, out);
\end{Verbatim}
        \end{column}
        \begin{column}{0.5\textwidth}
          High level
          \begin{Verbatim}[fontsize=\tiny]
P0M0 int input[10];
P0M1 int output[10];

void run(void) {
  for (int i=0; i<10; ++i)
    output[i] = input[i] * 2;
}
          \end{Verbatim}
        \end{column}
      \end{columns}
    \end{frame}
    \note{} % Empty filler note page

    \begin{frame}{What is Montium IR?}
      \begin{itemize}
        \item Status: Initial version
        \item Challenges:
        \begin{itemize}
          \item Backend is a fast moving target
          \item Corner cases
          \note[item]{Corner case --- global constants}
          \item Hardware dependencies
          \note[item]{Hardware --- Limited number of conditionals possible}
        \end{itemize}
      \end{itemize}
    \end{frame}

    \begin{frame}{Selecting LLVM transformations}
      \begin{itemize}
        \item Status: Done
        \item Challenges:
        \begin{itemize}
          \item LLVM Passes assume a lot
          \note[item]{Assumptions --- Immediates are not free}
          \item Montium has specific constraints
          \note[item]{Constraint --- Implicit cycle boundaries and ordering}
        \end{itemize}
      \end{itemize}
    \end{frame}

    \begin{frame}{Improving / adding transformations}
      \begin{itemize}
        \item Status: Ongoing
        \item Challenges:
        \begin{itemize}
          \item Staying generic
          \note[item]{Generic --- LLVM maintained passes are a lot easier}
          \item New LLVM features
          \note[item]{Features --- Multiple return values, inlining and
          annotation attributes}
        \end{itemize}
      \end{itemize}
    \end{frame}

    \begin{frame}{Debugging information}
      \begin{itemize}
        \item Status: Not started
        \item Challenges:
        \begin{itemize}
          \item Not much LLVM support yet
          \note[item]{LLVM support --- New in clang/backend, no support in
          transformations yet.}
          \item Transformations
          \note[item]{Transformations --- Global arguments, argument addition,
          removal, etc.}
        \end{itemize}
      \end{itemize}
    \end{frame}

    \begin{frame}{Reconfigurable binaries}
      \begin{itemize}
        \item Status: Recently started
        \item Challenges:
        \begin{itemize}
          \item Tracking variables
          \note[item]{Tracking --- Through all steps of the process}
          \item Loss of optimizations
          \note[item]{Optimizations --- Hard to encode constraints}
          \item Mostly a backend problem
        \end{itemize}
      \end{itemize}
    \end{frame}

\section{Work process}
  \begin{frame}{Working at Recore}
    \begin{itemize}
      \item Smart people
      \item Fast communication
      \note[item]{Communication --- Mixed teams, easy to "listen in".}
      \item Constructive brainstorming
      \note[item]{Brainstorming --- Evaluating different ideas and approaches.}
    \end{itemize}
  \end{frame}

  \begin{frame}{Working with LLVM}
    \begin{itemize}
      \item Large community
      \note[item]{Community --- Companies involved, a lot of full time
      developers.}
      \item Great support
      \note[item]{Support --- mailing list, bug reports solved within 1/2 days.}
      \item Slightly conflicting goals
      \note[item]{Goals --- LLVM aims mainly at "regular" architectures.}
    \end{itemize}
  \end{frame}

\section{Conclusions}
  \begin{frame}{Conclusions}
    \begin{itemize}
      \item LLVM is very suitable
      \item Defining the problem is harder than solving it
      \item Three months is short!
    \end{itemize}
  \end{frame}

\end{document}
