Jan Kończak

Your assignment is to implement a programming library for managing resources. Imagine a storage room where people can arrive with a list of items to take, and they are served first come-first served. If some items form their lists were taken by others, they simply wait until the items are returned. New categories (kinds) of items can always be added to the storage room. One can take a new set of items only after all previous items were returned.

Below, you are provided a header file with declarations of functions and the description of how they have to work. You must not modify the header file. For synchronization you must use the POSIX API.

Your code will be run against automated tests verifying example scenarios. Code that does not compile, or does not implement the functions from the header file, or uses API for synchronization other than the POSIX API will be graded negatively.

The solutions will be graded basing on the correctness of the code, use of fine-grained locking and correctness of memory management. Moreover, severe code illegibility, spaghetti code, code bloat and redundancy will lower the grade.

The deadline for the assignment is 01.06.2025 (AoE). Please send the solutions to me as a single attachment to an e-mail message with the subject beginning with [OSCP].

Please reach me by e-mail if anything there is not clear for you.

resources.h

#pragma once
 
/**
 * This function must be called before any other 'resources_*' function.
 * 
 * It may initialize data, but may as well be empty. It's up to you.
 */
void resources_init();
 
/**
 * Registers new kind of resource, and sets the number of items of this kind.
 * 
 * The function returns:
 *   • 0 on success
 *   • 1 if 'kind' is negative or 'availableCount' is nonpositive
 *   • 2 if resource of the provided 'kind' has already been created
 */
int resources_create(int kind, int availableCount);
 
/**
 * Takes resources according to specification. The 'what' argument is an array
 * of 'resources_request' structures, of length 'arrayLength'. Each element of
 * the array specifies a resource kind and the number of items to take.
 * 
 * This function waits until the resources become available.
 * 
 * Assigning resources must be done in first come - first served (first in -
 * first out) manner. That is, when a thread t₂ asked for the resources later
 * than t₁, then t₁ must not wait longer because of t₂ getting the resources
 * first. Notice that if it is possible to give resources to t₂ without causing
 * t₁ to wait longer, this has to be done.
 * 
 * A thread must not request resources it it still has some resources it did
 * not return.
 * 
 * The function returns:
 *   • 0 on success
 *   • 1 if array length is negative
 *   • 2 if the array has the same kind of resources on two indexes
 *   • 3 if the thread did not return some resourced that it took earlier
 *   • 4 if the thread requested a resource kind that was not yet created
 *   • 5 if the thread requested more resources of some kind than there exist
 */ 
struct resources_request {
    int kind;
    int count;
};
int resources_take(int arrayLength, struct resources_request *what);
 
/**
 * Returns a resource that was taken by the thread earlier on.
 * 
 * The resources can be returned in arbitrary order.
 * 
 * If multiple resources of the the same kind were taken, they may be returned
 * in portions.
 * 
 * The function returns:
 *   • 0 on success
 *   • 1 if the kind of resource does not exist
 *   • 2 if the thread did not take the resource it attempts to return
 *   • 3 if the thread attempts to return more resources than it took
 */
int resources_return(int kind, int count);

An example code that uses the library is provided here:

example.c

#include "resources.h"
#include <unistd.h>
#include <pthread.h>
 
void *t1(void *_);
void *t2(void *_);
void *t3(void *_);
void msg(int tid, const char *str);
 
enum {
    TABLE,
    CHAIR,
    LAMP,
    SPOON,
    CROW = 99,
};
 
int main() {
    resources_init();
    resources_create(TABLE, 2);
    resources_create(LAMP, 2);
    resources_create(CROW, 1);
    resources_create(CHAIR, 6);
 
    pthread_t i1, i2, i3;
    pthread_create(&i1, NULL, t1, NULL);
    pthread_create(&i2, NULL, t2, NULL);
    pthread_create(&i3, NULL, t3, NULL);
 
    struct resources_request res0[] = {{CHAIR, 2}};
        msg(0, "requests 2 chairs");
    resources_take(1, res0);
        msg(0, "got its chairs");
        usleep(100000);
        msg(0, "spawning spoons");
    resources_create(SPOON, 8);
        msg(0, "returns chairs");
    resources_return(CHAIR, 2);
 
    struct resources_request res2[] = {{LAMP, 1}, {SPOON, 4}};
        msg(0, "requests a lamp and 4 spoons");
    resources_take(2, res2);
        msg(0, "got a lamp and 4 spoons");
        usleep(300000);
        msg(0, "returns a lamp and 4 spoons");
    resources_return(LAMP, 1);
    resources_return(SPOON, 4);
 
    pthread_join(i1, NULL);
    pthread_join(i2, NULL);
    pthread_join(i3, NULL);
    return 0;
}
 
void *t1(void *_) {
    struct resources_request res1[] = {{TABLE, 1}, {LAMP, 2}, {CROW, 1}};
        msg(1, "requests a table, two lamps and a crow");
    resources_take(3, res1);
        msg(1, "got what it wanted");
        usleep(200000);
        msg(1, "returns crow and one lamp");
    resources_return(CROW, 1);
    resources_return(LAMP, 1);
        usleep(200000);
        msg(1, "returns the other lamp and a table");
    resources_return(LAMP, 1);
    resources_return(TABLE, 1);
    return NULL;
}
 
void *t2(void *_) {
        usleep(200000);
    struct resources_request res3[] = {{CHAIR, 2}, {LAMP, 1}};
        msg(2, "requests 2 chairs and a lamp");
    resources_take(2, res3);
        msg(2, "got what it wanted");
        usleep(100000);
        msg(2, "returns all it had");
    resources_return(CHAIR, 2);
    resources_return(LAMP, 1);
    return NULL;
}
 
void *t3(void *_) {
        usleep(300000);
    struct resources_request res4[] = {{CHAIR, 1}};
        msg(3, "requests a single chair");
    resources_take(1, res4);
        msg(3, "got a chair");
        usleep(100000);
        msg(3, "returns a chair");
    resources_return(CHAIR, 1);
    return NULL;
}
 
#include <stdio.h>
#include <time.h>
void msg(int tid, const char *str) {
    struct timespec tp; clock_gettime(CLOCK_REALTIME, &tp);
    static struct timespec worldstart = {0, 0};
    static int colors[] = {0, 32, 33, 36};
    if (worldstart.tv_sec == 0) worldstart = tp;
    tp.tv_sec  -= worldstart.tv_sec;
    tp.tv_nsec -= worldstart.tv_nsec;
    if (tp.tv_nsec < 0) { tp.tv_nsec += 1e9; tp.tv_sec--; }
    printf("\e[%dm%2ld.%03ld|t%d %s\e[0m\n", colors[tid], tp.tv_sec, tp.tv_nsec / (int)1e6, tid, str);
}

The output of the code above might be:

 0.000|t0 requests 2 chairs
 0.000|t0 got its chairs
 0.000|t1 requests a table, two lamps and a crow
 0.000|t1 got what it wanted
 0.100|t0 spawning spoons
 0.100|t0 returns chairs
 0.100|t0 requests a lamp and 4 spoons
 0.200|t2 requests 2 chairs and a lamp
 0.200|t1 returns crow and one lamp
 0.200|t0 got a lamp and 4 spoons
 0.300|t3 requests a single chair
 0.300|t3 got a chair
 0.400|t3 returns a chair
 0.400|t1 returns the other lamp and a table
 0.400|t2 got what it wanted
 0.500|t0 returns a lamp and 4 spoons
 0.500|t2 returns all it had

Jan Kończak

User Tools

Site Tools

Sidebar

Page Tools