Mercurial > pygar

     1 #include <stdio.h>

     2 #include <pthread.h>

     3 #include <semaphore.h>

     4 

     5 #include "asim/provides/connected_application.h"

     6 #include "asim/provides/stats_device.h"

     7 //#include "asim/provides/SndfileWavUtil.h"

     8 

     9 #include "asim/rrr/client_stub_AUDIOCORERRR.h"

    10 

    11 using namespace std;

    12 

    13 pthread_mutex_t CONNECTED_APPLICATION_CLASS::lock;

    14 pthread_cond_t  CONNECTED_APPLICATION_CLASS::cond;

    15 sem_t CONNECTED_APPLICATION_CLASS::throttle;

    16 

    17 // constructor

    18 CONNECTED_APPLICATION_CLASS::CONNECTED_APPLICATION_CLASS(VIRTUAL_PLATFORM vp) :

    19    

    20   clientStub(new AUDIOCORERRR_CLIENT_STUB_CLASS(this))

    21 {

    22 }

    23 

    24 // destructor

    25 CONNECTED_APPLICATION_CLASS::~CONNECTED_APPLICATION_CLASS()

    26 {

    27 }

    28 

    29 // init

    30 void

    31 CONNECTED_APPLICATION_CLASS::Init()

    32 {

    33 

    34   pthread_mutex_init(&lock, NULL);

    35   pthread_cond_init(&cond, NULL);

    36   sem_init(&throttle, 0, 64);

    37 

    38   // enable stats 

    39   STATS_DEVICE_SERVER_CLASS::GetInstance()->SetupStats();

    40 }

    41 

    42 void

    43 CONNECTED_APPLICATION_CLASS::UpdateSemaphore()

    44 {

    45   sem_post(&throttle);

    46 }

    47 

    48 void

    49 CONNECTED_APPLICATION_CLASS::EndSimulation()

    50 {

    51   printf("EndSimulation Called\n");

    52   fflush(stdout);

    53   pthread_mutex_lock(&lock);

    54   // Do something about the race occuring here

    55   pthread_cond_signal(&cond); 

    56   pthread_mutex_unlock(&lock);

    57   printf("EndSimulation done\n");

    58   fflush(stdout);  

    59 }

    60 

    61 // main

    62 void

    63 CONNECTED_APPLICATION_CLASS::Main()

    64 {

    65   //rlm: two files

    66   FILE *inputFile;

    67   FILE *inputFile1;

    68   UINT16 sample;

    69   UINT16 sample1;

    70 

    71   //rlm: not sure if normal ints are ok here; using UINT16 because I know it works

    72   UINT16 channel0 = 0;

    73   UINT16 channel1 = 1;

    74 

    75   //init processor 

    76   int sleepCount = 0;

    77   int result = 0;

    78 

    79   bool coreFin = false; 

    80 

    81   

    82 

    83   fflush(stdout); 

    84 

    85   // Convert input wav to pcm

    86  

    87 

    88   //rlm: for now we are going to going to just have 2 files with "common names"

    89 

    90   generate_pcm("input.wav","input.pcm");

    91   generate_pcm("input1.wav", "input1.pcm");

    92 

    93 

    94 

    95   //Send data to the machine here.

    96   //rlm: two files

    97   inputFile = fopen("input.pcm","r");

    98   inputFile = fopen("input1.pcm", "r");

    99   

   100   assert(inputFile1);

   101   assert(inputFile);

   102 

   103   int count = 0;

   104 

   105   printf("main:PROCESSOR about to enter loop %d\n", count);  

   106 

   107   //rlm: here we read both files. later refactor into a function.

   108   // also, this will terminate when the FIRST file reaches its end.

   109   while( (fread(&sample, 2, 1, inputFile)) && (fread(&sample1, 2 , 1, inputFile1))) {

   110     if (!coreFin && (result = clientStub->ReadCPUToHost(0)) != 1) 

   111     {

   112       sleepCount++;

   113       if(sleepCount == 200) {

   114 	printf("Failed to get response from hardware, bailing\n\n");

   115 	printf("This means that either your hardware is hanging\n");

   116 	printf("or that the software hasn't given it enough time\n");

   117 	printf("to complete.  If you think it needs more time, then\n");

   118 	printf("edit CONNECTED_APPLICATION_CLASS::Main() in ProcessorSystem.cpp\n");

   119         printf("(connected_application)\n");

   120       }

   121     }

   122     else if (!coreFin && result == 1) 

   123       {

   124 	printf("\n***SOFT_CORE PASSED***\n");

   125 	coreFin = true;

   126       }

   127 

   128     if(count%1000 == 0)

   129       printf("main: %d\n", count);

   130     count++;

   131     sem_wait(&throttle);

   132 

   133     //rlm: two files.

   134     clientStub->SendUnprocessedStream(channel0 , Data,(UINT32)sample);

   135     clientStub->SendUnprocessedStream(channel1 , Data,(UINT32)sample1);

   136 

   137   } 

   138 

   139   printf("main: out of loop\n");

   140 

   141   // Need to put lock here to prevent potential race condition

   142   pthread_mutex_lock(&lock);

   143 

   144   //rlm: have to send end-files to both voices.  

   145   // all of these operations wil eventually be moved into functions.

   146   clientStub->SendUnprocessedStream(channel0, EndOfFile,0);

   147   clientStub->SendUnprocessedStream(channel1, EndOfFile,0);

   148 

   149   printf("main: wait for end of file\n");

   150 

   151   pthread_cond_wait(&cond, &lock);

   152   pthread_mutex_unlock(&lock);

   153 

   154   printf("main: last data out\n");

   155 

   156   // Convert input wav to pcm

   157   // this part is ok because there is always only one input file.

   158   generate_wav("out_hw.pcm","input.wav","out_hw.wav");

   159 

   160   printf("generate wav done\n");

   161 

   162   printf("If you missed it, core %s", coreFin ? "PASSED\n" : "FAILED\n");

   163   // Dump the stats file

   164 

   165   STATS_DEVICE_SERVER_CLASS::GetInstance()->DumpStats();

   166   STATS_DEVICE_SERVER_CLASS::GetInstance()->EmitFile();

   167 

   168   fflush(stdout);

   169   exit(0);

   170 }
author	rlm
date	Tue, 04 May 2010 12:08:19 -0400
parents	0c775e733b81
children	99519a031813