previous-exams/2021-final-solutions/f3/project/MOOCSettings.scala

-package ch.epfl.lamp
-
-import sbt._
-import sbt.Keys._
-
-/**
- * Coursera uses two versions of each assignment. They both have the same assignment key and part id but have
- * different item ids.
- *
- * @param key Assignment key
- * @param partId Assignment partId
- * @param itemId Item id of the non premium version
- * @param premiumItemId Item id of the premium version (`None` if the assignment is optional)
- */
-case class CourseraId(key: String, partId: String, itemId: String, premiumItemId: Option[String])
-
-/**
-  * Settings shared by all assignments, reused in various tasks.
-  */
-object MOOCSettings extends AutoPlugin {
-
-  override def requires = super.requires && filteringReporterPlugin.FilteringReporterPlugin
-
-  object autoImport {
-    val course = SettingKey[String]("course")
-    val assignment = SettingKey[String]("assignment")
-    val options = SettingKey[Map[String, Map[String, String]]]("options")
-    val courseraId = settingKey[CourseraId]("Coursera-specific information identifying the assignment")
-    val testSuite = settingKey[String]("Fully qualified name of the test suite of this assignment")
-      .withRank(KeyRanks.Invisible)
-    // Convenient alias
-    type CourseraId = ch.epfl.lamp.CourseraId
-    val CourseraId = ch.epfl.lamp.CourseraId
-  }
-
-  import autoImport._
-
-  override val globalSettings: Seq[Def.Setting[_]] = Seq(
-    // supershell is verbose, buggy and useless.
-    useSuperShell := false
-  )
-
-  override val projectSettings: Seq[Def.Setting[_]] = Seq(
-    parallelExecution in Test := false,
-    // Report test result after each test instead of waiting for every test to finish
-    logBuffered in Test := false,
-    name := s"${course.value}-${assignment.value}"
-  )
-}

previous-exams/2021-final-solutions/f3/project/build.properties

-sbt.version=1.4.7

previous-exams/2021-final-solutions/f3/project/buildSettings.sbt

-// Used for Coursera submission (StudentPlugin)
-// libraryDependencies += "org.scalaj" %% "scalaj-http" % "2.4.2"
-// libraryDependencies += "com.typesafe.play" %% "play-json" % "2.7.4"
-// Used for Base64 (StudentPlugin)
-libraryDependencies += "commons-codec" % "commons-codec" % "1.10"

previous-exams/2021-final-solutions/f3/project/plugins.sbt

-// addSbtPlugin("org.scala-js" % "sbt-scalajs" % "0.6.28")
-addSbtPlugin("com.typesafe.play" % "sbt-plugin" % "2.8.8")
-addSbtPlugin("ch.epfl.lamp" % "sbt-dotty" % "0.5.3")

previous-exams/2021-final-solutions/f3/src/main/scala/f3/FileSystem.scala

-package f3
-
-import instrumentation._
-
-import scala.collection.mutable
-import scala.collection.concurrent.TrieMap
-
-type FileName = String
-
-/** An API for manipulating files. */
-trait FileSystem:
-  /** Create a new file named `file` with the passed `content`. */
-  def createFile(file: FileName, content: String): Unit
-  /** If `file` exists, return its content, otherwise crashes. */
-  def readFile(file: FileName): String
-  /** If `file` exists, delete it, otherwise crash. */
-  def deleteFile(file: FileName): Unit
-end FileSystem
-
-/** An in-memory file system for testing purposes implemented using a Map.
- *
- *  Every method in this class is thread-safe.
- */
-class InMemoryFileSystem extends FileSystem:
-  val fsMap: mutable.Map[FileName, String] = TrieMap()
-
-  def createFile(file: FileName, content: String): Unit =
-    assert(!fsMap.contains(file), s"$file already exists")
-    fsMap(file) = content
-
-  def readFile(file: FileName): String =
-    fsMap.get(file) match
-      case Some(content) => content
-      case None => assert(false, s"Attempt to read non-existing $file")
-
-  def deleteFile(file: FileName): Unit =
-    fsMap.remove(file)
-
-end InMemoryFileSystem

previous-exams/2021-final-solutions/f3/src/main/scala/f3/RCU.scala

-package f3
-
-import instrumentation._
-
-/** A synchronization mechanism allowing multiple reads to proceed concurrently
- *  with an update to the state.
- */
-class RCU extends Monitor:
-  protected val latestVersion: AtomicLong = AtomicLong(0)
-  protected val readersVersion: ThreadMap[Long] = ThreadMap()
-
-  /** This method must be called before accessing shared data for reading. */
-  def startRead(): Unit =
-    assert(!readersVersion.currentThreadHasValue,
-      "startRead() cannot be called multiple times without an intervening stopRead()")
-    readersVersion.setCurrentThreadValue(latestVersion.get)
-
-  /** Once a thread which has previously called `startRead` has finished reading
-   *  shared data, it must call this method.
-   */
-  def stopRead(): Unit =
-    assert(readersVersion.currentThreadHasValue,
-      "stopRead() cannot be called without a preceding startRead()")
-    readersVersion.deleteCurrentThreadValue()
-
-  /** Wait until all reads started before this method was called have finished,
-   *  then return.
-   */
-  def waitForOldReads(): Unit =
-
-    val newVersion = latestVersion.incrementAndGet()
-    readersVersion.waitForall(_ >= newVersion)

previous-exams/2021-final-solutions/f3/src/main/scala/f3/ThreadMap.scala

-package f3
-
-import instrumentation._
-
-import scala.collection.mutable
-
-/** A map which associates every thread to at most one value of type A.
- *
- *  Every method in this class is thread-safe.
- */
-class ThreadMap[A] extends Monitor:
-  protected val theMap: mutable.Map[Thread, A] = mutable.Map()
-
-  /** Return the value in the map entry for the current thread if it exists,
-   *  otherwise None. */
-  def currentThreadValue: Option[A] = synchronized {
-    theMap.get(Thread.currentThread)
-  }
-
-  /** Is there a map entry for the current thread? */
-  def currentThreadHasValue: Boolean =
-
-    synchronized {
-      theMap.contains(Thread.currentThread)
-    }
-
-  /** Set the map entry of the current thread to `value` and notify any thread
-   *  waiting on `waitForall`. */
-  def setCurrentThreadValue(value: A): Unit =
-
-    synchronized {
-      theMap(Thread.currentThread) = value
-      notifyAll()
-    }
-
-  /** Delete the map entry associated with this thread (if it exists) and notify
-   *  all threads waiting in `waitForall`. */
-  def deleteCurrentThreadValue(): Unit =
-
-    synchronized {
-      theMap.remove(Thread.currentThread)
-      notifyAll()
-    }
-
-  /** Wait until `predicate` returns true for all map entries, then return. */
-  def waitForall(predicate: A => Boolean): Unit =
-
-    synchronized {
-      while !theMap.forall((_, value) => predicate(value)) do
-        wait()
-    }
-
-end ThreadMap

previous-exams/2021-final-solutions/f3/src/main/scala/f3/UpdateServer.scala

-package f3
-
-import instrumentation._
-
-class UpdateServer(fs: FileSystem) extends Monitor:
-  val rcu = new RCU
-
-  /** The name of the file containing the latest update.
-   *
-   *  This is `@volatile` to guarantee that `fetchUpdate` always sees the latest
-   *  filename.
-   */
-  @volatile private var updateFile: Option[FileName] = None
-
-  /** Return the content of the latest update if one is available, otherwise None.
-   *
-   *  This method is thread-safe.
-   */
-  def fetchUpdate(): Option[String] =
-      // TODO: use `rcu`
-
-    rcu.startRead()
-    val value = updateFile.map(fs.readFile)
-    rcu.stopRead()
-    value
-
-  /** Define a new update, more precisely this will:
-   *  - Create a new update file called `newName` with content `newContent`
-   *  - Ensure that any future call to `fetchUpdate` returns the new update
-   *    content.
-   *  - Delete the old update file.
-   *
-   *  This method is _NOT_ thread-safe, it cannot be safely called from multiple
-   *  threads at once.
-   */
-  def newUpdate(newName: FileName, newContent: String): Unit =
-    // TODO: use `rcu`
-    val oldFile = updateFile
-    fs.createFile(newName, newContent)
-    updateFile = Some(newName)
-
-    rcu.waitForOldReads()
-    oldFile.foreach(fs.deleteFile)
-
-end UpdateServer

previous-exams/2021-final-solutions/f3/src/main/scala/f3/instrumentation/AtomicLong.scala

-package f3.instrumentation
-
-/** A long value that may be updated atomically. */
-class AtomicLong(initial: Long):
-
-  private val atomic = new java.util.concurrent.atomic.AtomicLong(initial)
-
-  /** Get the current value. */
-  def get: Long = atomic.get()
-
-  /** Set to the given `value`. */
-  def set(value: Long): Unit = atomic.set(value)
-
-  /** Atomically increment by one the current value and return the _original_ value. */
-  def getAndIncrement(): Long =
-    atomic.getAndIncrement()
-
-  /** Atomically increment by one the current value and return the _updated_ value. */
-  def incrementAndGet(): Long =
-    atomic.incrementAndGet()
-
-  /** Atomically set the value to `newValue` if the current value == `expected`.
-   *
-   *  Return true if successful, otherwise return false to indicate that the
-   *  actual value was not equal to the expected value.
-   */
-  def compareAndSet(expected: Long, newValue: Long): Boolean =
-    atomic.compareAndSet(expected, newValue)
-
-end AtomicLong

previous-exams/2021-final-solutions/f3/src/main/scala/f3/instrumentation/Monitor.scala

-package f3.instrumentation
-
-class Dummy
-
-trait Monitor {
-  implicit val dummy: Dummy = new Dummy
-
-  def wait()(implicit i: Dummy) = waitDefault()
-
-  def synchronized[T](e: => T)(implicit i: Dummy) = synchronizedDefault(e)
-
-  def notify()(implicit i: Dummy) = notifyDefault()
-
-  def notifyAll()(implicit i: Dummy) = notifyAllDefault()
-
-  private val lock = new AnyRef
-
-  // Can be overridden.
-  def waitDefault(): Unit = lock.wait()
-  def synchronizedDefault[T](toExecute: =>T): T = lock.synchronized(toExecute)
-  def notifyDefault(): Unit = lock.notify()
-  def notifyAllDefault(): Unit = lock.notifyAll()
-}

previous-exams/2021-final-solutions/f3/src/test/scala/f3/instrumentation/AtomicReference.scala

-package f3.instrumentation
-
-class AtomicReference[T](initial: T) {
-
-  private val atomic = new java.util.concurrent.atomic.AtomicReference[T](initial)
-
-  def get: T = atomic.get()
-
-  def set(value: T): Unit = atomic.set(value)
-}