pres.system.tex

   1 \subsection{Overview}
   2 \begin{frame}
   3         \frametitle{Current state of mTask}
   4         \begin{itemize}
   5                 \item Suits our needs as an EDSL
   6                 \item It all seems perfect
   7                 \item \ldots\pause{} but\ldots
   8                 \pause{}
   9                 \item No interaction
  10                 \item Compilation requires reprogramming
  11                 \item Entire system is created and fixed
  12         \end{itemize}
  13 \end{frame}
  14
  15 \begin{frame}
  16         \frametitle{Solution}
  17         \begin{itemize}[<+->]
  18                 \item Reuse mTask
  19                 \item New bytecode backend for mTask
  20                 \item Interpreter on client
  21                 \item Server in iTasks with integration
  22                 \item No taskserver generation, onetime programming
  23                 \item Dynamic task sending
  24         \end{itemize}
  25 \end{frame}
  26
  27 \subsection{Extending mTask}
  28 \begin{frame}[fragile]
  29         \frametitle{Adding a View}
  30         \begin{lstlisting}[language=Clean]
  31 :: ByteCode a p = BC (RWS () [BC] BCState ())
  32 :: BC           = BCNop | BCPush BCValue | ...
  33 :: BCValue      = E.e: BCValue e              & mTaskType, TC e
  34 :: BCShare      = { sdsi   :: Int, sdsval :: BCValue, sdsname :: String    }
  35 :: BCState      = { freshl :: Int, freshs :: Int,     sdss    :: [BCShare] }
  36
  37 instance ByteCode arith, boolExpr, ...
  38         \end{lstlisting}
  39 \end{frame}
  40
  41 \begin{frame}[fragile]
  42         \frametitle{Implementation}
  43         \begin{itemize}
  44                 \item Writing instruction
  45                 \item Carrying state
  46                 \item Hand-crafted helpers
  47         \end{itemize}
  48         \begin{lstlisting}[language=Clean]
  49 op2 :: (ByteCode a p1) (ByteCode a p2) BC -> ByteCode b Expr
  50 op2 (BC x) (BC y) bc = BC (x >>| y >>| tell [bc])
  51
  52 tell2 :: [BC] -> (ByteCode a p)
  53 tell2 x = BC (tell x)
  54
  55 instance arith ByteCode where
  56         lit x = tell2 [BCPush (BCValue x)]
  57         (+.) x y = op2 x y BCAdd
  58         ...
  59         \end{lstlisting}
  60 \end{frame}
  61
  62 \begin{frame}[fragile]
  63         \frametitle{Control flow}
  64         \begin{itemize}
  65                 \item Use labels
  66                 \item Label are resolved
  67                 \pause{}
  68                 \item Thus no reuse
  69         \end{itemize}
  70         \pause{}
  71         \begin{lstlisting}[language=Clean]
  72 :: BC = ... | BCLab Int | ...
  73
  74 freshlabel = get >>= \st=:{freshl}->put {st & freshl=freshl+1} >>| pure freshl
  75
  76 instance If ByteCode Stmt Stmt Stmt where If b t e = BCIfStmt b t e
  77 ...
  78 BCIfStmt (BC b) (BC t) (BC e) = BC (
  79         freshlabel >>= \else->freshlabel >>= \endif->
  80         b >>| tell [BCJmpF else] >>|
  81         t >>| tell [BCJmp endif, BCLab else] >>|
  82         e >>| tell [BCLab endif]
  83         )
  84         \end{lstlisting}
  85 \end{frame}
  86
  87 \begin{frame}[fragile]
  88         \frametitle{Assignment and SDSs}
  89         \begin{lstlisting}[language=Clean]
  90 instance sds ByteCode where
  91         sds f = {main = BC (freshshare
  92                         >>= \sdsi->pure {BCShare|sdsname="",sdsi=sdsi,sdsval=BCValue 0}
  93                         >>= \sds->pure (f (tell2 [BCSdsFetch sds]))
  94                         >>= \(v In bdy)->modify (addSDS sds v)
  95                         >>| unBC (unMain bdy))
  96                 }
  97
  98 instance assign ByteCode where
  99         (=.) (BC v) (BC e) = BC (e >>| censor makeStore v)
 100
 101 instance sdspub ByteCode where
 102         pub (BC x) = BC (censor (\[BCSdsFetch s]->[BCSdsPublish s]) x)
 103
 104 makeStore [BCSdsFetch i]    = [BCSdsStore i]
 105 makeStore [BCDigitalRead i] = [BCDigitalWrite i]
 106 makeStore [...]             = [...]
 107         \end{lstlisting}
 108 \end{frame}
 109
 110 \begin{frame}[fragile]
 111         \frametitle{Bandwidth is scarce}
 112         Publish SDS explicitly
 113         \pause{}
 114         \begin{lstlisting}
 115 class sdspub v where
 116         pub :: (v t Upd) -> (v () Stmt)
 117 instance sdspub ByteCode where
 118         pub (BC x) = BC (censor (\[BCSdsFetch s]->[BCSdsPublish s]) x)
 119         \end{lstlisting}
 120 \end{frame}
 121
 122 \begin{frame}[fragile]
 123         \frametitle{Task scheduling}
 124         \begin{block}{Old}
 125                 \begin{itemize}
 126                         \item Task server
 127                         \item Tasks start other tasks
 128                 \end{itemize}
 129         \end{block}
 130         \pause{}
 131         \begin{block}{New}
 132                 \begin{itemize}[<+->]
 133                         \item Old system, taskserver, tasks start tasks
 134                         \item New system, task+strategy
 135                         \item \CI{OnShot}, \CI{OnInterval}, \CI{OnInterrupt}
 136                         \item How to handle termination
 137                 \end{itemize}
 138                 \pause{}
 139                 \begin{lstlisting}[language=Clean]
 140 class retrn v where
 141         retrn :: v () Expr
 142                 \end{lstlisting}
 143         \end{block}
 144 \end{frame}
 145
 146 \subsection{Devices}
 147 \begin{frame}[fragile]
 148         \frametitle{Devices}
 149         \begin{itemize}[<+->]
 150                 \item Standard C client software
 151                 \item Modular implementation
 152                 \item Specification generated from the macros
 153         \end{itemize}
 154
 155         \begin{lstlisting}[language=C,caption={interface.h}]
 156 ...
 157 #elif defined TARGET_STM32F767ZI
 158 #define APINS 128
 159 #define DPINS 128
 160 #define STACKSIZE 1024
 161 #define MEMSIZE 1024
 162 #define HAVELED 1
 163 #define HAVEHB 1
 164
 165 #elif defined ARDUINO_ESP8266_NODEMCU
 166 ...
 167 bool input_available(void);
 168 uint8_t read_byte(void);
 169 void write_byte(uint8_t b);
 170
 171 #if DPINS > 0
 172 void write_dpin(uint8_t i, bool b);
 173 ...
 174         \end{lstlisting}
 175 \end{frame}
 176
 177 \begin{frame}[fragile]
 178         \frametitle{Storage}
 179         \begin{itemize}[<+->]
 180                 \item Heap is there, but inefficient
 181                 \item Allocate space in global data
 182                 \item Selfmanage it
 183                 \item Tasks grow up
 184                 \item SDSs grow down
 185                 \item Compacting on removal
 186         \end{itemize}
 187         \pause{}
 188         \begin{lstlisting}[language=C]
 189 struct task {
 190         uint16_t tasklength;
 191         uint16_t interval;
 192         unsigned long lastrun;
 193         uint8_t taskid;
 194         uint8_t *bc;
 195 };
 196         \end{lstlisting}
 197 \end{frame}
 198
 199 \begin{frame}[fragile]
 200         \frametitle{Interpreter}
 201         Stack machine, modular
 202         \pause{}
 203         \begin{lstlisting}[language=C]
 204 #define f16(p) program[pc]*265+program[pc+1]
 205
 206 void run_task(struct task *t){
 207         uint8_t *program = t->bc;
 208         int plen = t->tasklength, pc = 0, sp = 0;
 209         while(pc < plen){
 210                 switch(program[pc++]){
 211                 case BCPUSH:
 212                         stack[sp++] = pc++ //Simplified
 213                         break;
 214                 case BCADD:
 215                         stack[sp-2] = stack[sp-2] + stack[sp-1];
 216                         sp -= 1;
 217                         break;
 218                 case BCJMPT:
 219                         pc = stack[--sp] ? program[pc]-1 : pc+1;
 220                         break;
 221 #if APINS > 0
 222                 case BCANALOGREAD:
 223                         ...
 224         \end{lstlisting}
 225 \end{frame}
 226
 227 \subsection{Server}
 228 \begin{frame}[fragile]
 229         \frametitle{Device storage}
 230         \begin{lstlisting}[language=Clean]
 231 :: Channels :== ([MTaskMSGRecv], [MTaskMSGSend], Bool)
 232 :: MTaskResource
 233         = TCPDevice TCPSettings
 234         | SerialDevice TTYSettings
 235         | ...
 236 :: MTaskDevice =
 237         { deviceTask     :: Maybe TaskId , deviceError    :: Maybe String
 238         , deviceChannels :: String       , deviceName     :: String
 239         , deviceState    :: BCState      , deviceTasks    :: [MTaskTask]
 240         , deviceResource :: MTaskResource
 241         , deviceSpec     :: Maybe MTaskDeviceSpec
 242         , deviceShares   :: [MTaskShare]
 243         }
 244
 245 channels :: MTaskDevice -> Shared Channels
 246
 247 class MTaskDuplex a where
 248         synFun :: a (Shared Channels) -> Task ()
 249         \end{lstlisting}
 250 \end{frame}
 251
 252 \begin{frame}
 253         \frametitle{SDS storage}
 254         \begin{block}{Approaches}
 255                 \begin{itemize}[<+->]
 256                         \item One SDS per SDS
 257                         \item One SDS per Device and map
 258                         \item One SDS in the entire system and map
 259                 \end{itemize}
 260         \end{block}
 261
 262         \pause{}
 263
 264         \begin{block}{Notifications}
 265                 \begin{itemize}[<+->]
 266                         \item Tasks monitoring the SDSs
 267                         \item Parametric lenses!
 268                 \end{itemize}
 269         \end{block}
 270 \end{frame}
 271
 272 \begin{frame}[fragile]
 273         \frametitle{SDS (2)}
 274         \framesubtitle{Parametric Lenses}
 275         \begin{block}{What is the \CI{p} for in \CI{RWShared p r w}}
 276                 \pause{}
 277                 \begin{itemize}
 278                         \item Parameter fixed when writing
 279                         \item Used for notifications
 280                         \item On write the SDS returns \CI{p -> Bool}
 281                 \end{itemize}
 282         \end{block}
 283         \begin{lstlisting}[language=Clean]
 284 sdsFocus :: p1 (RWShared p1 r w) -> RWShared p2 r w | iTask p
 285         \end{lstlisting}
 286 \end{frame}
 287
 288 \begin{frame}[fragile]
 289         \frametitle{Solve the notification problem and how to relay information?}
 290         \begin{itemize}
 291                 \item Tailor made share
 292                 \item The read and write functions have the World
 293         \end{itemize}
 294
 295         \pause{}
 296
 297         \begin{onlyenv}<2>
 298                 \begin{lstlisting}[language=Clean]
 299 :: P :== Maybe (MTaskDevice, Int)
 300 deviceStore :: RWShared P [MTaskDevice] [MTaskDevice]
 301 deviceStore = SDSSource {SDSSource
 302         | name="deviceStore", read=realRead, write=realWrite}
 303 where
 304         realDeviceStore :: Shared [MTaskDevice]
 305         realDeviceStore = sharedStore "mTaskDevices" []
 306
 307         realRead :: P *IWorld
 308                 -> (MaybeError TaskException [MTaskDevice], *IWorld)
 309         realRead p iw = read realDeviceStore iw
 310                 \end{lstlisting}
 311         \end{onlyenv}
 312
 313         \begin{onlyenv}<3>
 314                 \begin{lstlisting}[language=Clean]
 315 realWrite :: P [MTaskDevice] *IWorld
 316         -> (MaybeError TaskException (SDSNotifyPred P), *IWorld)
 317 realWrite mi w iw
 318 # (merr, iw) = write w realDeviceStore iw
 319 | isNothing mi = (Ok $ gEq{|*|} mi, iw)
 320 # (Just (dev, ident)) = mi
 321 | ident == -1 = (Ok $ gEq{|*|} mi, iw)
 322 = case find ((==)dev) w of
 323         Nothing = (Error $ exception "Device lost", iw)
 324         Just {deviceShares} = case find (\d->d.identifier == ident) deviceShares of
 325                 Nothing = (Error $ exception "Share lost", iw)
 326                 Just s = case sendMessagesIW [MTUpd ident s.MTaskShare.value] dev iw of
 327                         (Error e, iw) = (Error e, iw)
 328                         (Ok _, iw) = (Ok $ gEq{|*|} mi, iw)
 329                 \end{lstlisting}
 330         \end{onlyenv}
 331 \end{frame}
 332
 333 \begin{frame}[fragile]
 334         \frametitle{Specific SDS functions}
 335         \begin{lstlisting}
 336 deviceStoreNP :: Shared [MTaskDevice]
 337 deviceStoreNP = sdsFocus Nothing deviceStore
 338
 339 deviceShare :: MTaskDevice -> Shared MTaskDevice
 340 deviceShare d = mapReadWriteError
 341         ( \ds->case find ((==)d) ds of
 342                 Nothing = exception "Device lost"
 343                 Just d = Ok d)
 344         , \w ds->case splitWith ((==)d) ds of
 345                 ([], _) = Error $ exception "Device lost"
 346                 ([_:_], ds) = Ok $ Just [w:ds])
 347         $ sdsFocus (Just (d, -1)) deviceStore
 348
 349 shareShare :: MTaskDevice MTaskShare -> Shared BCValue
 350 ...
 351 \end{lstlisting}
 352 \end{frame}
 353
 354 \subsection{Communication}
 355 \begin{frame}
 356         \frametitle{The glue of the system}
 357         \begin{itemize}
 358                 \item Compile, send and interact with Tasks
 359                 \item Interact with SDSs
 360                 \item All communication via channels
 361         \end{itemize}
 362 \end{frame}
 363
 364 \begin{frame}[fragile]
 365         \frametitle{Messages}
 366         \begin{lstlisting}[language=Clean]
 367 :: MTaskId :== Int
 368 :: MSDSId :== Int
 369 :: MTaskFreeBytes :== Int
 370 :: MTaskMSGRecv
 371         = MTTaskAck MTaskId MTaskFreeBytes | MTTaskDelAck MTaskId
 372         | MTSDSAck MSDSId                  | MTSDSDelAck MSDSId
 373         | MTPub MSDSId BCValue             | MTMessage String
 374         | MTDevSpec MTaskDeviceSpec        | MTEmpty
 375
 376 :: MTaskMSGSend
 377         = MTTask MTaskInterval String | MTTaskDel MTaskId
 378         | MTShutdown                  | MTSds MSDSId BCValue
 379         | MTUpd MSDSId BCValue        | MTSpec
 380         \end{lstlisting}
 381 \end{frame}
 382
 383 \begin{frame}[fragile]
 384         \frametitle{Connecting with a device}
 385         \begin{lstlisting}[language=Clean]
 386 process :: MTaskDevice (Shared Channels) -> Task ()
 387 process ...
 388
 389 makeDevice :: String MTaskResource -> MTaskDevice
 390
 391 connectDevice :: MTaskDevice -> Task MTaskDevice
 392 connectDevice device = set ([], [], False) ch
 393         >>| appendTopLevelTask newMap True
 394         (       process device ch -||- catchAll (getSynFun device.deviceData ch) errHdl)
 395         >>= \tid->upd (\d->{d&deviceTask=Just tid,deviceError=Nothing}) (deviceShare device)
 396         >>| set (r,[MTSpec],ss) ch
 397         >>| treturn device
 398 where
 399         errHdl e = upd (\d->{d & deviceTask=Nothing, deviceError=Just e}) (deviceShare device) @! ()
 400         ch = channels device
 401         \end{lstlisting}
 402 \end{frame}
 403
 404 \begin{frame}
 405         \frametitle{Compilation}
 406         \begin{itemize}[<+->]
 407                 \item Get device's compiler state
 408                 \item Run the RWS
 409                 \item Resolve labels
 410                 \item Instantiate shares
 411                 \item Convert to messages
 412                 \item Update state
 413                 \item Send the messages
 414         \end{itemize}
 415 \end{frame}
 416
 417 \begin{frame}[fragile]
 418         \frametitle{Interaction with devices}
 419         \begin{block}{Send task}
 420                 \begin{lstlisting}[language=Clean]
 421 sendTaskToDevice :: String (Main (ByteCode a Stmt)) (MTaskDevice, MTaskInterval)
 422         -> Task (MTaskTask, [MTaskShare])
 423                 \end{lstlisting}
 424         \end{block}
 425 \end{frame}
 426
 427 \begin{frame}[fragile]
 428         \frametitle{Example, blink}
 429         \begin{lstlisting}[language=Clean]
 430 blink :: Task ()
 431 blink =       addDevice
 432         >>=       connectDevice
 433         >>= \stm->sendTaskToDevice "blink" blinkTask (stm, OnInterval 1000)
 434         >>= \(st, [_,t])->forever (
 435                 updateSharedInformation "Which led to blink" [] (shareShare stm t)
 436         ) >>* [OnAction (Action "Shutdown") $ always
 437                 $ deleteDevice stm >>| shutDown 0
 438         ]
 439 where
 440         blinkTask = sds \led=LED1 In sds \x=True In {main =
 441                 ledOff led1 :. ledOff led2 :. ledOff led3 :.
 442                 IF x (ledOff led) (ledOn led) :.
 443                 x =. Not x}
 444         \end{lstlisting}
 445 \end{frame}