Diff: main.cpp

Revision:

4:8a7e0bc98db0

Parent:

3:8647bf7682b2

--- a/main.cpp	Thu Oct 29 22:29:08 2015 +0000
+++ b/main.cpp	Wed Nov 16 02:54:46 2016 +0000
@@ -3,278 +3,27 @@
 #include "SDFileSystem.h"
 #include "rtos.h"
 
-#define CTIME   50
-#define WTIME   150
-
-SDFileSystem sd(PTE3, PTE1, PTE2, PTE4, "sd"); 
-Serial pc(USBTX, USBRX);
-DigitalOut ledr(LED_RED);
-DigitalOut ledg(LED_GREEN);
-DigitalOut ledb(LED_BLUE);
-Timer ProgramTimer;
-
-int n_threads = 0;
-int i = 0;
-int j = 0;
-int k = 0;
-int l = 0;
-int n = 0;
-
-typedef struct {
-  int id;
-  int cap;
-  int n_objects;
-  int weight[32];
-  int value[32];
-} knapsack;
-
-typedef struct {
-  int tid;
-  int led;
-  int pid;
-  int cap;
-  int optimal;
-  int n_solutions;
-  int weight[32];
-  int value[32];
-  unsigned long ts_begin;
-  unsigned long ts_end;
-} solution;
-
-char *temp;
-int *ttemp;
-int *vsol;
-int *wsol;
-int sol = 0;
-
-int phead, ptail;
-int shead, stail;
-knapsack *knapsacks;
-knapsack *pQueue;
-knapsack salida;
-solution *solutions;
-solution output;
-
-Thread *threads[10];
-
-Mutex mutex_p;
-Mutex mutex_s;
-
-int max(int a, int b);
-solution KnapSack(int W, int wt[], int val[], int n);
-void init_pQueue(void);
-void init_sQueue(void);
-int ispEmpty();
-int issEmpty();
-void pEnqueue(knapsack p);
-void sEnqueue(solution s);
-knapsack pDequeue();
-solution sDequeue();
+Thread *threads[4];
 
 void worker(void const *args);
 
 int main(){
-    ledr=1; ledg=1; ledb=1; 
-    FILE *ptr_file;
-    char *plinea = (char *)malloc(128*sizeof(char));
-    char *linea = (char *)malloc(128*sizeof(char));
-    char *temp = (char *)malloc(4*sizeof(char));
-    int *ttemp = (int *)malloc(128*sizeof(int));
-    knapsacks = (knapsack *)malloc(32*sizeof(knapsack));
-    pQueue = (knapsack *)malloc(32*sizeof(knapsack));
-    solutions = (solution *)malloc(32*sizeof(solution));
     
-    pc.baud(115200);
-    pc.printf("\n\rInitializing\n\r");
-    pc.printf("============ \n\r");
-    wait(0.5f);
-    
-    ProgramTimer.start(); 
-    ptr_file = fopen("/sd/test.txt","r");
-    
-    fgets(plinea,512,ptr_file);
-    n_threads = plinea[1]-'0';
-    init_pQueue();
-    init_sQueue();
-    
-    n=0;
-    while( !feof(ptr_file) ){
-        fgets(linea,512,ptr_file);
-        i=1; j=0; l=0;
-        while(linea[i]!='*'){
-            if (linea[i]!=','){
-                temp[j]=linea[i];
-                j++;
-            } else {
-                temp[j]='\0';
-                ttemp[l]=atoi(temp);
-                j=0; l++;
-            }
-            ttemp[l]=atoi(temp);
-            i++;
-        }
-        for(k=0;k<=l;k++){
-            if(k==0) knapsacks[n].id=ttemp[k];
-            if(k==1) knapsacks[n].cap=ttemp[k];
-            if((k>1)&&((k%2)==0)) knapsacks[n].weight[k/2-1]=ttemp[k];
-            if((k>2)&&((k%2)!=0)) knapsacks[n].value[k/2-1]=ttemp[k];
-        }
-        knapsacks[n].n_objects=l/2;
-        pEnqueue(knapsacks[n]);
-        n++;
+    for(int i=0;i<4;i++){
+       threads[i] = new Thread(worker,(void *)(i+1));
+       Thread::wait(500);
     }
     
-    pc.printf("id\tcap\tn\titems\n\r");
-    for(i=0;i<n;i++){
-        pc.printf("%d\t%d\t%d\t",knapsacks[i].id,knapsacks[i].cap,knapsacks[i].n_objects);
-        for(j=0;j<knapsacks[i].n_objects;j++) pc.printf("%d,%d ",knapsacks[i].weight[j],knapsacks[i].value[j]);
-        pc.printf("\n\r");
+    while(1){
     }
-    pc.printf("\n\r");
-    
-    fclose(ptr_file);
-    free(plinea);
-    free(linea);
-    free(temp);
-    free(ttemp);
-    
-    /*pc.printf("No Thread Solution\n\r");
-    pc.printf("==================\n\r");
-    pc.printf("#tid\t#pid\tcap\tsol\titems\n\r");
-    for(j=0;j<n;j++){
-        solutions[j] = KnapSack(knapsacks[j].cap,knapsacks[j].weight,knapsacks[j].value,knapsacks[j].n_objects);
-        pc.printf("main\t%d\t%d\t%d\t",j+1,knapsacks[j].cap,solutions[j].optimal);
-        for(i=0;i<solutions[j].n_solutions;i++) pc.printf("%d,%d,",solutions[j].weight[i],solutions[j].value[i]);
-        pc.printf("\n\r");
-    }*/
-    pc.printf("\n\r");   
-    pc.printf("Thread Solution\n\r");
-    pc.printf("===============\n\r");
-    
-    for(i=0;i<n_threads;i++){
-       threads[i] = new Thread(worker,(void *)(i+1));
-       Thread::wait(CTIME);
-    }
-    pc.printf("&%d*\n\r",n_threads);
-    
-    while(1){
-        if(!issEmpty()){
-            mutex_s.lock();
-            output = sDequeue();
-            mutex_s.unlock();
-            pc.printf("#%d(%d),%d,%d,",output.led,output.tid,output.pid,output.cap);
-            for(i=0;i<output.n_solutions;i++) pc.printf("%d,%d,",output.weight[i],output.value[i]);
-            pc.printf("%.3f,%.3f,%.3f*\n\r",output.ts_begin/1000.0f,output.ts_end/1000.0f,(output.ts_end-output.ts_begin)/1000.0f);
-            ledr = !(output.led/2/2);
-            ledg = !(output.led/2%2);
-            ledb = !(output.led%2);
-        } else{
-            free(knapsacks);
-            free(pQueue);
-            free(solutions);
-        }
-        Thread::wait(1000);
+}
+
+void worker(void const *args){
+    while (true) {
+        Thread::wait(500);
+        osThreadYield();
     }
 }
 
 
-solution KnapSack(int cap, int weight[], int value[], int n){
-    solution s;
-    int i, w;
-    int j = 0;
-    int sol = 0;
-    int K[n+1][cap+1];
-    s.ts_begin = ProgramTimer.read_us();
-    for(i=0;i<=n;i++){
-        for(w=0;w<=cap;w++){
-            if(i==0||w==0) K[i][w]=0;
-            else if(weight[i-1]<=w) K[i][w]=max(value[i-1]+K[i-1][w-weight[i-1]],K[i-1][w]);
-            else K[i][w]=K[i-1][w];
-        }
-    }
-    w=cap;
-    for(i=n;i>0;i--){
-        if(K[i][w]!=K[i-1][w]){
-            s.value[j] = value[i-1];
-            s.weight[j] = weight[i-1];
-            w=w-weight[i-1];
-            sol++;
-            j++;
-        }
-    }
-    s.ts_end = ProgramTimer.read_us();
-    s.optimal = K[n][cap];
-    s.n_solutions = sol;
-    return s;
-}
 
-int max(int a, int b){
-    return (a>b)?a:b;
-}
-
-void init_pQueue(void){
-    phead = ptail = -1;
-}
-
-int ispEmpty(){
-    return (phead == ptail);
-}
-
-void pEnqueue(knapsack p){
-    ptail++;
-    pQueue[ptail] = p;
-}
-
-knapsack pDequeue(){
-    knapsack p;
-    phead++;
-    p = pQueue[phead];
-    return p;
-}
-
-void init_sQueue(void){
-    shead = stail = -1;
-}
-
-int issEmpty(){
-    return (shead == stail);
-}
-
-
-void sEnqueue(solution s){
-    stail++;
-    solutions[stail] = s;
-}
-
-solution sDequeue(){
-    solution s;
-    shead++;
-    s = solutions[shead];
-    return s;
-}
-
-void worker(void const *args){
-    solution temp;
-    knapsack doc;
-    osThreadId id;
-    while (true) {
-        if(!ispEmpty()){
-            mutex_p.lock();
-            doc = pDequeue();
-            mutex_p.unlock();      
-            temp = KnapSack(doc.cap,doc.weight,doc.value,doc.n_objects);
-            temp.pid = doc.id;
-            temp.cap = doc.cap;
-            temp.tid = (uint32_t)osThreadGetId();
-            temp.led = (uint32_t)args;
-            mutex_s.lock();
-            sEnqueue(temp);
-            mutex_s.unlock();
-        } else{
-            id = osThreadGetId();
-            osThreadTerminate(id);
-        }
-        Thread::wait(WTIME);
-        osThreadYield();
-    }
-}