Skip to navigation | Skip to main content | Skip to footer
Menu
Menu

COMP30112: Concurrency (2007-2008)

This is an archived syllabus from 2007-2008

Concurrency
Level: 3
Credit rating: 10
Pre-requisites: COMP10020 or equivalent (e.g. CS1021 COMP10021 or MATH10111 or MATH10131 or MATH10212 or MATH10232 or MATH10662 or MATH10672)
Co-requisites: No Co-requisites
Duration: 11 weeks
Lectures: 22, including examples classes and optional lab exercises
Lecturers: Howard Barringer
Course lecturer: Howard Barringer

Additional staff: view all staff
Timetable
SemesterEventLocationDayTimeGroup
Sem 2 w19-25,29-32 Lecture IT407 Mon 14:00 - 15:00 -
Sem 2 w19-25,29-32 Lecture 1.4 Thu 15:00 - 16:00 -
Assessment Breakdown
Exam: 100%
Coursework: 0%
Lab: 0%
Degrees for which this unit is optional
  • Artificial Intelligence BSc (Hons)

Aims

This course will provide a systematic treatment of concepts and issues in concurrency. The subject will be introduced via a small process algebra language, FSP, for specifying the concurrent behaviour of finite state processes. The Java language has built-in concurrency constructs and will be used to illustrate implementations of example specifications. Also the FSP language comes with software tools for animation and verification and these will be used in examples.

A wide variety of common concurrency problems will be investigated. Some of the underlying theory of the process algebra FSP and related algebras such as Milner's CCS and Hoare's CSP will be studied.

The course aims to:
Provide students with an understanding of concurrent systems, in particular how to model them using the process algebra FSP and how to implement them using Java.
Study techniques for the analysis of concurrent systems.
Introduce, via a set of case-studies, typical methods for solving concurrency problems.
Allow students to use a suite of tools for analysing FSP systems.

Learning Outcomes

On completion of this module, a student will:

Have a knowledge and understanding, both practical and theoretical, of the FSP Process Algebra. (A)
Have a knowledge and understanding of the difficulties involved in designing and implementing concurrent systems, and the limitations of the FSP modelling approach. (A)
Have a knowledge and understanding of the behaviour of concurrent Java programs. (A)
Have a knowledge and understanding of solutions to a range of concurrency problems and be able to evaluate the effectiveness of these. (A and B)
Be able to construct models for concurrent systems using FSP. (B)
Be able to reason about FSP systems, including analysis of their behaviour, properties and equivalencies. (B)
Understand how to use Java concurrency primitives. (B)
Be able to translate FSP models to Java implementations for small problems. (B and C)

Assessment of Learning outcomes

All learning outcomes will be formally assessed via the exam.

The automated analysis tools for FSP from the course text book will be available, together with the suite of example programs. Although not formally assessed, students will be strongly encouraged to use the tools in order to reinforce their understanding. Students will also be strongly encouraged to modify and produce Java implementations for selected problems. Informal exercises will be issued throughout the course and a number of examples classes will be scheduled.

Contribution to Programme Learning Outcomes

Referring to Computer Science Programme Learning Outcomes: A1: process algebra; labelled transition systems; operational semantics; equivalences (Learning outcome 1) A2: language for supporting concurrent systems (Learning outcome 3) A5: principles and techniques for concurrent system applications (Learning outcome 4) B1: model construction (Learning outcome 5) and analysis of problems (Learning outcome 6) B3: evaluation of concurrent system design (Learning outcome 4) C5: design and implement concurrent programs (not formally assessed) (Learning outcome 8) C6: use LTSA tool for analysis (not formally assessed) D1: exam requires effective communication; questions in lectures D6: basic discrete maths skills utilised

Syllabus

Introduction


Problems and challenges in concurrency (1 lecture).

Modelling processes and concurrency using FSP


Communicating processes, labelled transition systems (2 lectures).

Concurrency in Java


Threads, constructs, behaviour, interacting multiple threads (3 lectures).

From specification to implementation


Translating FSP to Java (1 lecture).

FSP


Semantics and equivalence (3 lectures).

Mutual exclusion, monitors, semaphores (3 lectures)


Properties


Deadlock, safety, liveness, fairness (4 lectures).

Applications


Readers/writers, message-passing, termination (4 lectures).

Extending the model


Other process algebras (CSP, CSS) (1 lecture).

Exercises/revision (2 lectures)