12. Cvičení: Práce na projektu

Obsahem cvičení je samostatná práce na projektu a konzultace (projektu, témat z přednášek…).

• Ukázkový kód využívající posix threads pro vícevláknovou aplikaci. Ukazuje možné rozdělení projektu do vláken
  • main - hlavní vlákno
  • input_thread - vstupní vlákno
  • output_thread - výstupní vlákno
  • V tomto případě je vykreslování na LCD realizováno kontinuelně a ne on-demand. Variant řešení je samozřejmě více. Template si klade za cíl hlavně ukázat práci s posixovými vlákny.

  • #define _POSIX_C_SOURCE 200112L
     
    #include <stdlib.h>
    #include <stdio.h>
    #include <stdint.h>
    #include <time.h>
    #include <unistd.h>
    #include <stdbool.h>
     
    #include <pthread.h>
     
    #include "mzapo_parlcd.h"
    #include "mzapo_phys.h"
    #include "mzapo_regs.h"
    #include "serialize_lock.h"
     
    #define IMG_SIZE 320*480
     
    //type definition of struct for shared data between threads
    typedef struct { 
      bool quit;
      unsigned char *parlcd_mem_base;
      uint16_t * fb_read;
      uint16_t * fb_write;
    } data_t;
     
    void * input_thread(void * data);
    void * output_thread(void * data);
     
    //mutexes for double buffering of frames
    pthread_mutex_t mtx_fb; 
     
    int main(int argc, char *argv[])
    {
     
      // Serialize execution of applications
      // Try to acquire lock the first 
      if (serialize_lock(1) <= 0) {
        printf("System is occupied\n");
     
        if (1) {
          printf("Waiting\n");
          // Wait till application holding lock releases it or exits
          serialize_lock(0);
        }
      }
     
      printf("Hello world\n");
     
      //initialize the two frame buffers
      uint16_t fb0[IMG_SIZE]; 
      uint16_t fb1[IMG_SIZE]; 
     
      //initialize the shared data
      data_t shared_data;
      shared_data.quit = false;
      shared_data.fb_read = &fb0;
      shared_data.fb_write = &fb1;
     
      //map the memory
      shared_data.parlcd_mem_base = map_phys_address(PARLCD_REG_BASE_PHYS, PARLCD_REG_SIZE, 0);
      if (shared_data.parlcd_mem_base == NULL){
        exit(1);
      }
     
      //prepare the threads
      enum {INPUT, OUTPUT, NUM_THREADS};
      const char *thread_names[] = {"input", "output"}; 
      void* (*thread_functions[])(void *) = {input_thread, output_thread};
     
      //initialize the threads and mutex
      pthread_t threads[NUM_THREADS];
      pthread_mutex_init(&mtx_fb, NULL);
     
      //spawn the threads
      for (int i = 0; i < NUM_THREADS; ++i){
        int res = pthread_create(&threads[i], NULL, thread_functions[i], &shared_data);
        fprintf(stdout, "INFO: Create thread '%s' %s\n", thread_names[i], (res == 0 ? "OK" : "FAIL") );
        //TODO:correctly exit if some thread does not initialize
      }
     
      //main loop
      uint16_t color = 0x0000;
     
      while(!shared_data.quit){
        //simulate some long calculations 
        usleep(10000);
     
        //write the frame buffer
        for (int i = 0; i < IMG_SIZE; i++) {
          //write to the write buffer     
          shared_data.fb_write[i] = color;
        }
        color+=1;
     
        //swap the buffers - first need to acquire the mutex for write read buffer
        pthread_mutex_lock(&mtx_fb);
        //..now swap them
        uint16_t * tmp = shared_data.fb_read;
        shared_data.fb_read = shared_data.fb_write;
        shared_data.fb_write = tmp;
        //..and unlock the read buffer for display
        pthread_mutex_unlock(&mtx_fb);
     
      }
      shared_data.quit = true;
     
      //joining the threads
      for (int i = 0; i < NUM_THREADS; ++i) {
          fprintf(stdout, "INFO: Call join to the thread %s\n", thread_names[i]);
          int r = pthread_join(threads[i], NULL);
          fprintf(stdout, "INFO: Joining the thread %s has been %s\n", thread_names[i], (r == 0 ? "OK" : "FAIL"));
       }
     
      printf("Goodbye world\n");
     
      // Release the lock 
      serialize_unlock();
     
      return 0;
    }
     
     
    //------------------------------------------------------------
    void * input_thread(void * data){
      data_t * shared_data = (data_t *) data;
     
      while(!shared_data->quit){
        //TODO: sample the input once in a while
        char c = getchar();
        if (c == 'q'){
          shared_data->quit = true;
        }
     
        //sleep for some time
        usleep(10000);
      }
    }
     
    //------------------------------------------------------------
    void * output_thread(void * data){
      data_t * shared_data = (data_t *) data;
     
      //initialize the display
      parlcd_hx8357_init(shared_data->parlcd_mem_base);
     
      uint16_t fb_p = NULL;
      //draw in infinite loop
      while(!shared_data->quit){
     
        //lock the output frame buffer so no one can write into it
        pthread_mutex_lock(&mtx_fb);
        //reset the cursor
        parlcd_write_cmd(shared_data->parlcd_mem_base, 0x2c);
        //write the buffer
        for (int i = 0; i < IMG_SIZE; ++i) {
            parlcd_write_data(
              shared_data->parlcd_mem_base, shared_data->fb_read[i]);
        }
        //unlock the buffer 
        pthread_mutex_unlock(&mtx_fb);
     
        //sleep for some time
        usleep(10000);
      }
    }