Database Engineering Hackathon

In a concurrent system, there is a file F which consists of records X1,X2, ....Xn. The structure of the record is X.

Let’s suppose there is an application program A which understands this file and interprets and can concurrently Read/Write/Modify these records. That is, multiple instances of A concurrently access F and may read/add/update data in the process. Due to certain business case this record structure X needs to be modified to X' and hence all the records in the file also need to be moved to newer structure. All this to be done with minimal effect on concurrent users running multiple instances of A simultaneously. In addition, user should be able to abort/restart this X--> X' migration operation any number of times.

You can make your own assumption on the structures X and X' and how instances of A access F concurrently. Design and implement a system, that can achieve movement of business requirement with minimal downtime. Users using A should be able to move to using application A' which understands newer structure X'.

Produce userspace reliable UDP transmission for IPv4 networks, to gain better performance with the following features:

a) TCP-like connect/disconnect features, albeit without the need for a 3-way handshake.
b) Error detection/correction.
c) Minimize retransmissions due to missing datagrams.
d) For the sake of performance, in-order delivery is not required, although flow control should be implemented.
e) NAT traversal is preferred but not required.

Measure performance against normal TCP for the same peers using tools you are comfortable with.

ISO/IEC 9075 defines a standard on SQL. However, to offer more flexibility/efficiency, several DBMSes provide their proprietary extensions and features used by client users. This causes application portability issues to other DBMS. Here, the problem is to produce a client library for relational DBMSes which converts an original DBMS (e.g., MySQL or Oracle or MS SQL) query to Postgres native wire protocol.

Application > Original DB Client > Original DBMS

TO

Application > Our DB Client > PostgreSQL

We do not expect the problem to be completely solved, but novelty and complexity of the solution is the key. The said library should provide C/C++ APIs pluggable to the source DB. Document the features provided by the library and provide source code for testing the same.

Consider the case when multiple user space threads write to more than one device concurrently. It is required for these threads to synchronize the reads/writes using OS level locking primitives. Although useful to perform operations in correct order, it may be bit penalizing on performance. Here problem is that in the operation arena of I/O scheduler it does not have any of this information. Also, application is completely oblivious to scheduler mechanisms. However, application may know the relation or possible order of operations, if there is any, between consecutive writes/reads. Due to this application may employ special purpose interfaces that can chain operations which obey a “happens-before” relationship, while rest may be processed out of order. Benefit of this is that some of the I/O operations could be processed without locks or other synchronization mechanisms.

The problem is to devise a mechanism that can be used by I/O scheduler in linux kernel which can leverage this chaining relation between successive I/O operations, and hence may speed up I/O. You may choose to modify any existing Linux I/O scheduler of your choice.

Covert Channel in Applications - Generally computer programs have high degree of cohesion, which helps hacker in understanding the logic and hence may use it to alter the flow of victim program to rather restricted areas (e.g. features which can be used after paying up). In this way the information flow from module A--> module B--> module C--> .... can be traced. 

It is required for all the modules are part of same executable.

Produce a covert channel in an application of your choice (you may create your own), such that -- information reaches to the destination module C through at least two different paths A-->B-->C and through covert channel --> C. In this way, hacker must do much more work in flawless application operation of victim application.