int main(int argc, char* argv[])
{
    int         err, num_engines;
    int*        stream;
    uint32_t    cell_score_threshold;
    uint32_t**  query_ids;
    char *  ref_buf;
    char *** query_buf;
    int **       query_len;
    char        ibuf[1024];
    uint32_t **  results_buf;
    PicoDrv     *pico;
    const char* bitFileName;
    const char* ref_filename;
    int num_queries;
    pthread_t* read_thread;
    pthread_t* write_thread;
    read_thread_args* rta;
    write_thread_args* wta;

    // specify the .bit file name on the command line
    if (argc < 6) {
        fprintf(stderr, "Usage: ./SmithWatermanAccelerator <BIT FILE> <NUM_ENGINES> <CELL SCORE THRESHOLD> <REF SEQ FILE> <QUERY SEQ FILE 1> [<QUERY SEQ FILE 2> ...]");
        exit(1);
    }
    bitFileName = argv[1];
    num_engines = atoi(argv[2]);
    cell_score_threshold = (uint32_t) atoi(argv[3]);
    ref_filename = argv[4];
    num_queries = argc - 5;
    const char* query_filenames[num_queries];
    for (int i = 0; i < num_queries; i++) {
        query_filenames[i] = argv[i+5];
    }
    
    // Read ref seq file into memory
    std::ifstream ref_file;
    std::ifstream::pos_type ref_size;
    ref_file.open(ref_filename, std::ios::in | std::ios::binary | std::ios::ate);
    if (ref_file.is_open()) {
        ref_size = ref_file.tellg();
        ref_buf = new char[ref_size];
        ref_file.seekg(0, std::ios::beg);
        ref_file.read(ref_buf, ref_size);
        ref_file.close();
        printf("Read ref seq file '%s' of length %iB\n", ref_filename, (int) ref_size); 
    } else {
        fprintf(stderr, "Unable to open ref seq file '%s'", ref_filename);
        exit(1);
    }
    
    // Read query seq files into memory
    query_buf = new char** [num_engines];
    query_len = new int* [num_engines];
    query_ids = new uint32_t* [num_engines];
    int num_queries_per_engine[num_engines];
    for (int i = 0; i < num_engines; i++) {
        if (i < num_queries % num_engines) {
            num_queries_per_engine[i] = (num_queries / num_engines) + 1;
        } else {
            num_queries_per_engine[i] = num_queries / num_engines;
        }
    }
    for (int i = 0; i < num_engines; i++) {
        query_buf[i] = new char* [num_queries_per_engine[i]];
        query_len[i] = new int [num_queries_per_engine[i]];
        query_ids[i] = new uint32_t [num_queries_per_engine[i]];
    }
    int cur_engine = 0;
    for (int i = 0; i < num_queries; i++) {
        std::ifstream query_file;
        std::ifstream::pos_type query_size;
        query_file.open(query_filenames[i], std::ios::in | std::ios::binary | std::ios::ate);
        if (query_file.is_open()) {
            query_size = query_file.tellg();
            query_len[cur_engine][i/num_engines] = (int) query_size;
            query_buf[cur_engine][i/num_engines] = new char[query_size];
            query_ids[cur_engine][i/num_engines] = i;
            query_file.seekg(0, std::ios::beg);
            query_file.read(query_buf[cur_engine][i/num_engines], query_size);
            query_file.close();
            printf("Read query seq file '%s' of length %iB for engine %i\n", query_filenames[i], (int) query_size, cur_engine);
            cur_engine++;
            cur_engine %= num_engines;
        } else {
            fprintf(stderr, "Unable to open query seq file '%s'", query_filenames[i]);
            exit(1);
        }
    }

/*
    query_buf = new char* [num_queries];
    query_len = new int [num_queries];
    for (int i = 0; i < num_queries; i++) {
        std::ifstream query_file;
        std::ifstream::pos_type query_size;
        query_file.open(query_filenames[i], std::ios::in | std::ios::binary | std::ios::ate);
        if (query_file.is_open()) {
            query_size = query_file.tellg();
            query_len[i] = (int) query_size;
            query_buf[i] = new char[query_size];
            query_file.seekg(0, std::ios::beg);
            query_file.read(query_buf[i], query_size);
            query_file.close();
            printf("Read query seq file '%s' of length %iB\n", query_filenames[i], (int) query_size);
        } else {
            fprintf(stderr, "Unable to open query seq file '%s'", query_filenames[i]);
            exit(1);
        }
    }*/
    
    // The RunBitFile function will locate a Pico card that can run the given bit file, and is not already
    //   opened in exclusive-access mode by another program. It requests exclusive access to the Pico card
    //   so no other programs will try to reuse the card and interfere with us.
    printf("Loading FPGA with '%s' ...\n", bitFileName);
    err = RunBitFile(bitFileName, &pico);
    if (err < 0) {
        // We use the PicoErrors_FullError function to decipher error codes from RunBitFile.
        // This is more informative than just printing the numeric code, since it can report the name of a
        //   file that wasn't found, for example.
        fprintf(stderr, "RunBitFile error: %s\n", PicoErrors_FullError(err, ibuf, sizeof(ibuf)));
        exit(1);
    }
    
    // Open streams to engines
    printf("Opening streams\n");
    stream = new int[num_engines];
    for (int i = 0; i < num_engines; i++) {
        stream[i] = pico->CreateStream(i+1);
        if (stream[i] < 0) {
            fprintf(stderr, "couldn't open stream %i! (return code: %i)\n", i+1, stream[i]);
            exit(1);
        }
    }
    
    // Write reference sequence to the DRAM
    printf("Writing ref seq to DRAM\n");
    err = pico->WriteRam(0, ref_buf, ref_size, PICO_DDR3_0);
    if (err < 0) {
        fprintf(stderr, "WriteRam error: %s\n", PicoErrors_FullError(err, ibuf, sizeof(ibuf)));
        exit(1);
    } else if (err != ref_size) {
        fprintf(stderr, "WriteRam wrote %i bytes instead of the desire %i bytes\n", err, (int) ref_size);
        exit(1);
    }
    sleep(1);
  
    // Start read/write threads 
    printf("Starting Smith Waterman tests\n");
    results_buf = new uint32_t* [num_engines];
    for (int i = 0; i < num_engines; i++) {
        results_buf[i] = new uint32_t[RESULT_BUF_SIZE];
        for (int j = 0; j < RESULT_BUF_SIZE; j++) {
            results_buf[i][j] = 0;
        }
    }
    wta = new write_thread_args[num_engines];
    rta = new read_thread_args[num_engines];
    for (int i = 0; i < num_engines; i++) {
        wta[i].pico = pico;
        wta[i].stream = stream[i];
        wta[i].num_queries = num_queries_per_engine[i];
        wta[i].query_len_bytes = query_len[i];
        wta[i].query_buf = query_buf[i];
        wta[i].ref_len_bytes = (int) ref_size;
        wta[i].cell_score_threshold = cell_score_threshold;
        wta[i].engine_id = i;
        wta[i].query_ids = query_ids[i];
        rta[i].pico = pico;
        rta[i].stream = stream[i];
        rta[i].results_buf = results_buf[i];
        rta[i].num_queries = num_queries_per_engine[i];
        rta[i].engine_id = i;
        rta[i].query_ids = query_ids[i];
    }

    read_thread = new pthread_t[num_engines];
    write_thread = new pthread_t[num_engines];
    for (int i = 0; i < num_engines; i++) {
        pthread_create(&(read_thread[i]), NULL, &stream_read_thread, (void*) &(rta[i]));
        pthread_create(&(write_thread[i]), NULL, &stream_write_thread, (void*) &(wta[i]));
    }
    for (int i = 0; i < num_engines; i++) {
        pthread_join(read_thread[i], NULL);
        pthread_join(write_thread[i], NULL);
    }

    for (int i = 0; i < num_engines; i++) {
        for (int j = 0; j < RESULT_BUF_SIZE; j++) {
            printf("%i\t", results_buf[i][j]);
        }
        printf("\n\n");
    }

    // streams are automatically closed when the PicoDrv object is destroyed, or on program termination, but
    //   we can also close a stream manually.
    for (int i = 0; i < num_engines; i++) {
        pico->CloseStream(stream[i]);
    }
    return 0;
}
Пример #2
0
int main(int argc, char* argv[])
{
  int         err, i, j, stream;
  int         room;
  int         *tmp = NULL;
  int         stream11, stream12, stream13;
  int         stream21, stream22, stream23;
  int         stream31, stream32, stream33;
  int         stream41, stream42, stream43;
  int         stream51, stream52, stream53;
  int         stream61, stream62, stream63;
  int         stream71, stream72, stream73;
  int         stream81, stream82, stream83;

  uint32_t    buf[1024], u32, addr;
  char        ibuf[1024];
  PicoDrv     *pico;
  const char* bitFileName;
  printf("Start\r\n");
  // specify the .bit file name on the command line
    switch(argc) {

      case 1: {
        if ((err = FindPico(0x505, &pico)) < 0) {
            printf("FindPico Error\r\n");
            return err;
        }
      }break;

      case 2: {
        bitFileName = argv[1];
        printf("Loading FPGA with '%s' ...\n", bitFileName);
        err = RunBitFile(bitFileName, &pico);
        if (err < 0) {
            fprintf(stderr, "RunBitFile error: %s\n", PicoErrors_FullError(err, ibuf, sizeof(ibuf)));
            exit(1);
        }
      }break;
    }

  printf("Opening stream50 (CMD)\r\n");
  stream = pico->CreateStream(50);
  if (stream < 0) {
      fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream, ibuf, sizeof(ibuf)));
      exit(1);
  }
//==============================================================================
  int *A = new int[SIZE];
  int *B = new int[SIZE];
  int *C = new int[SIZE];
  int *D = new int[SIZE];


  for (i = 0; i < SIZE; i++) {
    A[i] = i + 1;
    B[i] = i + 1;
    C[i] = 0;
    D[i] = 0;
  }
  struct timeval start, end;
  gettimeofday(&start, NULL);
  for (i = 0; i < SIZE; i++) {
    C[i] = A[i] + B[i];
  }
  gettimeofday(&end, NULL);

  int timeuse = 1000000 * (end.tv_sec - start.tv_sec) + end.tv_usec - start.tv_usec;
  printf("CPU %4d threads :\t%9d us\r\n", 1, timeuse);



  // printf("Opening stream21 (CMD)\r\n");
  // stream21 = pico->CreateStream(21);
  // if (stream21 < 0) {
  //     fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream21, ibuf, sizeof(ibuf)));
  //     exit(1);
  // }

  // printf("Opening stream22 (CMD)\r\n");
  // stream22 = pico->CreateStream(22);
  // if (stream22 < 0) {
  //     fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream22, ibuf, sizeof(ibuf)));
  //     exit(1);
  // }

  // printf("Opening stream23 (CMD)\r\n");
  // stream23 = pico->CreateStream(23);
  // if (stream23 < 0) {
  //     fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream23, ibuf, sizeof(ibuf)));
  //     exit(1);
  // }

  // printf("Opening stream31 (CMD)\r\n");
  // stream31 = pico->CreateStream(31);
  // if (stream31 < 0) {
  //     fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream31, ibuf, sizeof(ibuf)));
  //     exit(1);
  // }

  // printf("Opening stream32 (CMD)\r\n");
  // stream32 = pico->CreateStream(32);
  // if (stream32 < 0) {
  //     fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream32, ibuf, sizeof(ibuf)));
  //     exit(1);
  // }

  // printf("Opening stream33 (CMD)\r\n");
  // stream33 = pico->CreateStream(33);
  // if (stream33 < 0) {
  //     fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream33, ibuf, sizeof(ibuf)));
  //     exit(1);
  // }

  // printf("Opening stream41 (CMD)\r\n");
  // stream41 = pico->CreateStream(41);
  // if (stream41 < 0) {
  //     fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream41, ibuf, sizeof(ibuf)));
  //     exit(1);
  // }

  // printf("Opening stream42 (CMD)\r\n");
  // stream42 = pico->CreateStream(42);
  // if (stream42 < 0) {
  //     fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream42, ibuf, sizeof(ibuf)));
  //     exit(1);
  // }

  // printf("Opening stream43 (CMD)\r\n");
  // stream43 = pico->CreateStream(43);
  // if (stream43 < 0) {
  //     fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream43, ibuf, sizeof(ibuf)));
  //     exit(1);
  // }

  // printf("Opening stream51 (CMD)\r\n");
  // stream51 = pico->CreateStream(51);
  // if (stream51 < 0) {
  //     fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream51, ibuf, sizeof(ibuf)));
  //     exit(1);
  // }

  // printf("Opening stream52 (CMD)\r\n");
  // stream52 = pico->CreateStream(52);
  // if (stream52 < 0) {
  //     fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream52, ibuf, sizeof(ibuf)));
  //     exit(1);
  // }

  // printf("Opening stream53 (CMD)\r\n");
  // stream53 = pico->CreateStream(53);
  // if (stream53 < 0) {
  //     fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream53, ibuf, sizeof(ibuf)));
  //     exit(1);
  // }

  // printf("Opening stream61 (CMD)\r\n");
  // stream61 = pico->CreateStream(61);
  // if (stream61 < 0) {
  //     fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream61, ibuf, sizeof(ibuf)));
  //     exit(1);
  // }

  // printf("Opening stream62 (CMD)\r\n");
  // stream62 = pico->CreateStream(62);
  // if (stream62 < 0) {
  //     fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream62, ibuf, sizeof(ibuf)));
  //     exit(1);
  // }

  // printf("Opening stream63 (CMD)\r\n");
  // stream63 = pico->CreateStream(63);
  // if (stream63 < 0) {
  //     fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream63, ibuf, sizeof(ibuf)));
  //     exit(1);
  // }

  // printf("Opening stream71 (CMD)\r\n");
  // stream71 = pico->CreateStream(71);
  // if (stream71 < 0) {
  //     fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream71, ibuf, sizeof(ibuf)));
  //     exit(1);
  // }

  // printf("Opening stream72 (CMD)\r\n");
  // stream72 = pico->CreateStream(72);
  // if (stream72 < 0) {
  //     fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream72, ibuf, sizeof(ibuf)));
  //     exit(1);
  // }

  // printf("Opening stream73 (CMD)\r\n");
  // stream73 = pico->CreateStream(73);
  // if (stream73 < 0) {
  //     fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream73, ibuf, sizeof(ibuf)));
  //     exit(1);
  // }

  int node;
  uint32_t  cmd[4]; // {0xC1100000, 0xC1200000, 0xC1300001, 0xB1000000};
//==================================================================================================
//       _    ____ ____       _
//      / \  / ___/ ___|  _  / |
//     / _ \| |  | |     (_) | |
//    / ___ \ |__| |___   _  | |
//   /_/   \_\____\____| (_) |_|
//==================================================================================================
#ifdef ACC1
  printf("Opening stream11 (CMD)\r\n");
  stream11 = pico->CreateStream(11);
  if (stream11 < 0) {
      fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream11, ibuf, sizeof(ibuf)));
      exit(1);
  }

  printf("Opening stream12 (CMD)\r\n");
  stream12 = pico->CreateStream(12);
  if (stream12 < 0) {
      fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream12, ibuf, sizeof(ibuf)));
      exit(1);
  }

  printf("Opening stream13 (CMD)\r\n");
  stream13 = pico->CreateStream(13);
  if (stream13 < 0) {
      fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream13, ibuf, sizeof(ibuf)));
      exit(1);
  }

  cmd[0] = 0xC1100000;
  cmd[1] = 0xC1200000 | SIZE;
  cmd[2] = 0xC1300001;
  cmd[3] = 0xB1000000;
  pico->WriteStream(stream, cmd, 16);

  // printf("Lanching ACC\r\n");
  // cmd[0] = 0xA1000000;
  // cmd[1] = 0x00000000;
  // cmd[2] = 0x00000000;
  // cmd[3] = 0x00000000;
  // pico->WriteStream(stream, cmd, 16);

  pico->WriteStream(stream11, A, SIZE * 4);
  pico->WriteStream(stream12, B, SIZE * 4);
  // printf("%i B available to read from firmware.\n", i=pico->GetBytesAvailable(stream13, true));
  // if (i < 0){
  //     fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
  //     exit(1);
  // }
  i = SIZE * 4;
  room = i / 4;
  tmp = new int[room];
  pico->ReadStream(stream13, tmp, i);
  printf("%d\r\n", room);
  for (i = 0; i < room; i++) {
    printf("[%d] 0x%08x\r\n", i, tmp[i]);
  }

  // printf("%i B available to read from firmware.\n", i=pico->GetBytesAvailable(stream, true));
  // if (i < 0){
  //     fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
  //     exit(1);
  // }
  // room = i / 4;
  // tmp = new int[room];
  // pico->ReadStream(stream, tmp, i);
  // printf("%d\r\n", room);
  // for (i = 0; i < room; i++) {
  //   printf("[%d] 0x%08x\r\n", i, tmp[i]);
  // }
  delete[] tmp;
#endif
//==================================================================================================
//       _    ____ ____       ____
//      / \  / ___/ ___|  _  |___ \
//     / _ \| |  | |     (_)   __) |
//    / ___ \ |__| |___   _   / __/
//   /_/   \_\____\____| (_) |_____|
//==================================================================================================
//   cmd[0] = 0xC2100000;
//   cmd[1] = 0xC2200000 | SIZE;
//   cmd[2] = 0xC2300001;
//   cmd[3] = 0xB2000000;
//   pico->WriteStream(stream, cmd, 16);

//   printf("Lanching ACC\r\n");
//   cmd[0] = 0xA2000000;
//   cmd[1] = 0x00000000;
//   cmd[2] = 0x00000000;
//   cmd[3] = 0x00000000;
//   pico->WriteStream(stream, cmd, 16);

//   err = pico->WriteStream(stream21, A, SIZE * 4);
//   err = pico->WriteStream(stream22, B, SIZE * 4);
//   printf("%i B available to read from stream23.\n", i=pico->GetBytesAvailable(stream23, true));
//   if (i < 0){
//       fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
//       exit(1);
//   }
//   room = i / 4;
//   tmp = new int[room];
//   err = pico->ReadStream(stream23, tmp, i);
//   if (err < 0) {
//       fprintf(stderr, "ReadStream stream23 error: %s\n", PicoErrors_FullError(err, ibuf, sizeof(ibuf)));
//       exit(1);
//   }
//   printf("%d\r\n", room);
//   for (i = 0; i < room; i++) {
//     printf("[%d] 0x%08x\r\n", i, tmp[i]);
//   }

//   printf("%i B available to read from stream.\n", i=pico->GetBytesAvailable(stream, true));
//   if (i < 0){
//       fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
//       exit(1);
//   }
//   room = i / 4;
//   tmp = new int[room];
//   pico->ReadStream(stream, tmp, i);
//   printf("%d\r\n", room);
//   for (i = 0; i < room; i++) {
//     printf("[%d] 0x%08x\r\n", i, tmp[i]);
//   }
//   delete[] tmp;
//==============================================================================
//       _    ____ ____       _____
//      / \  / ___/ ___|  _  |___ /
//     / _ \| |  | |     (_)   |_ \
//    / ___ \ |__| |___   _   ___) |
//   /_/   \_\____\____| (_) |____/
//==============================================================================
//   cmd[0] = 0xC3100000;
//   cmd[1] = 0xC3200000 | SIZE;
//   cmd[2] = 0xC3300001;
//   cmd[3] = 0xB3000000;
//   pico->WriteStream(stream, cmd, 16);

//   printf("Lanching ACC\r\n");
//   cmd[0] = 0xA3000000;
//   cmd[1] = 0x00000000;
//   cmd[2] = 0x00000000;
//   cmd[3] = 0x00000000;
//   pico->WriteStream(stream, cmd, 16);

//   err = pico->WriteStream(stream31, A, SIZE * 4);
//   err = pico->WriteStream(stream32, B, SIZE * 4);
//   printf("%i B available to read from stream33.\n", i=pico->GetBytesAvailable(stream33, true));
//   if (i < 0){
//       fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
//       exit(1);
//   }
//   room = i / 4;
//   tmp = new int[room];
//   err = pico->ReadStream(stream33, tmp, i);
//   if (err < 0) {
//       fprintf(stderr, "ReadStream stream33 error: %s\n", PicoErrors_FullError(err, ibuf, sizeof(ibuf)));
//       exit(1);
//   }
//   printf("%d\r\n", room);
//   for (i = 0; i < room; i++) {
//     printf("[%d] 0x%08x\r\n", i, tmp[i]);
//   }

//   printf("%i B available to read from stream.\n", i=pico->GetBytesAvailable(stream, true));
//   if (i < 0){
//       fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
//       exit(1);
//   }
//   room = i / 4;
//   tmp = new int[room];
//   pico->ReadStream(stream, tmp, i);
//   printf("%d\r\n", room);
//   for (i = 0; i < room; i++) {
//     printf("[%d] 0x%08x\r\n", i, tmp[i]);
//   }
//   delete[] tmp;
//==============================================================================
//       _    ____ ____       _  _
//      / \  / ___/ ___|  _  | || |
//     / _ \| |  | |     (_) | || |_
//    / ___ \ |__| |___   _  |__   _|
//   /_/   \_\____\____| (_)    |_|
//==============================================================================
//   cmd[0] = 0xC4100000;
//   cmd[1] = 0xC4200000 | SIZE;
//   cmd[2] = 0xC4300001;
//   cmd[3] = 0xB4000000;
//   pico->WriteStream(stream, cmd, 16);

//   printf("Lanching ACC\r\n");
//   cmd[0] = 0xA4000000;
//   cmd[1] = 0x00000000;
//   cmd[2] = 0x00000000;
//   cmd[3] = 0x00000000;
//   pico->WriteStream(stream, cmd, 16);

//   err = pico->WriteStream(stream41, A, SIZE * 4);
//   err = pico->WriteStream(stream42, B, SIZE * 4);
//   printf("%i B available to read from stream43.\n", i=pico->GetBytesAvailable(stream43, true));
//   if (i < 0){
//       fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
//       exit(1);
//   }
//   room = i / 4;
//   tmp = new int[room];
//   err = pico->ReadStream(stream43, tmp, i);
//   if (err < 0) {
//       fprintf(stderr, "ReadStream stream43 error: %s\n", PicoErrors_FullError(err, ibuf, sizeof(ibuf)));
//       exit(1);
//   }
//   printf("%d\r\n", room);
//   for (i = 0; i < room; i++) {
//     printf("[%d] 0x%08x\r\n", i, tmp[i]);
//   }

//   printf("%i B available to read from stream.\n", i=pico->GetBytesAvailable(stream, true));
//   if (i < 0){
//       fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
//       exit(1);
//   }
//   room = i / 4;
//   tmp = new int[room];
//   pico->ReadStream(stream, tmp, i);
//   printf("%d\r\n", room);
//   for (i = 0; i < room; i++) {
//     printf("[%d] 0x%08x\r\n", i, tmp[i]);
//   }
//   delete[] tmp;
// //==============================================================================
// //       _    ____ ____       ____
// //      / \  / ___/ ___|  _  | ___|
// //     / _ \| |  | |     (_) |___ \
// //    / ___ \ |__| |___   _   ___) |
// //   /_/   \_\____\____| (_) |____/
// //==============================================================================
//   cmd[0] = 0xC5100000;
//   cmd[1] = 0xC5200000 | SIZE;
//   cmd[2] = 0xC5300001;
//   cmd[3] = 0xB5000000;
//   pico->WriteStream(stream, cmd, 16);

//   printf("Lanching ACC\r\n");
//   cmd[0] = 0xA5000000;
//   cmd[1] = 0x00000000;
//   cmd[2] = 0x00000000;
//   cmd[3] = 0x00000000;
//   pico->WriteStream(stream, cmd, 16);

//   err = pico->WriteStream(stream51, A, SIZE * 4);
//   err = pico->WriteStream(stream52, B, SIZE * 4);
//   printf("%i B available to read from stream53.\n", i=pico->GetBytesAvailable(stream53, true));
//   if (i < 0){
//       fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
//       exit(1);
//   }
//   room = i / 4;
//   tmp = new int[room];
//   err = pico->ReadStream(stream53, tmp, i);
//   if (err < 0) {
//       fprintf(stderr, "ReadStream stream53 error: %s\n", PicoErrors_FullError(err, ibuf, sizeof(ibuf)));
//       exit(1);
//   }
//   printf("%d\r\n", room);
//   for (i = 0; i < room; i++) {
//     printf("[%d] 0x%08x\r\n", i, tmp[i]);
//   }

//   printf("%i B available to read from stream.\n", i=pico->GetBytesAvailable(stream, true));
//   if (i < 0){
//       fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
//       exit(1);
//   }
//   room = i / 4;
//   tmp = new int[room];
//   pico->ReadStream(stream, tmp, i);
//   printf("%d\r\n", room);
//   for (i = 0; i < room; i++) {
//     printf("[%d] 0x%08x\r\n", i, tmp[i]);
//   }
//   delete[] tmp;
// //==============================================================================
// //       _    ____ ____        __
// //      / \  / ___/ ___|  _   / /_
// //     / _ \| |  | |     (_) | '_ \
// //    / ___ \ |__| |___   _  | (_) |
// //   /_/   \_\____\____| (_)  \___/
// //==============================================================================
//   cmd[0] = 0xC6100000;
//   cmd[1] = 0xC6200000 | SIZE;
//   cmd[2] = 0xC6300001;
//   cmd[3] = 0xB6000000;
//   pico->WriteStream(stream, cmd, 16);

//   printf("Lanching ACC\r\n");
//   cmd[0] = 0xA6000000;
//   cmd[1] = 0x00000000;
//   cmd[2] = 0x00000000;
//   cmd[3] = 0x00000000;
//   pico->WriteStream(stream, cmd, 16);

//   err = pico->WriteStream(stream61, A, SIZE * 4);
//   err = pico->WriteStream(stream62, B, SIZE * 4);
//   printf("%i B available to read from stream63.\n", i=pico->GetBytesAvailable(stream63, true));
//   if (i < 0){
//       fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
//       exit(1);
//   }
//   room = i / 4;
//   tmp = new int[room];
//   err = pico->ReadStream(stream63, tmp, i);
//   if (err < 0) {
//       fprintf(stderr, "ReadStream stream63 error: %s\n", PicoErrors_FullError(err, ibuf, sizeof(ibuf)));
//       exit(1);
//   }
//   printf("%d\r\n", room);
//   for (i = 0; i < room; i++) {
//     printf("[%d] 0x%08x\r\n", i, tmp[i]);
//   }

//   printf("%i B available to read from stream.\n", i=pico->GetBytesAvailable(stream, true));
//   if (i < 0){
//       fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
//       exit(1);
//   }
//   room = i / 4;
//   tmp = new int[room];
//   pico->ReadStream(stream, tmp, i);
//   printf("%d\r\n", room);
//   for (i = 0; i < room; i++) {
//     printf("[%d] 0x%08x\r\n", i, tmp[i]);
//   }
//   delete[] tmp;
// //==============================================================================
// //       _    ____ ____       _____
// //      / \  / ___/ ___|  _  |___  |
// //     / _ \| |  | |     (_)    / /
// //    / ___ \ |__| |___   _    / /
// //   /_/   \_\____\____| (_)  /_/
// //==============================================================================
//   cmd[0] = 0xC7100000;
//   cmd[1] = 0xC7200000 | SIZE;
//   cmd[2] = 0xC7300001;
//   cmd[3] = 0xB7000000;
//   pico->WriteStream(stream, cmd, 16);

//   printf("Lanching ACC\r\n");
//   cmd[0] = 0xA7000000;
//   cmd[1] = 0x00000000;
//   cmd[2] = 0x00000000;
//   cmd[3] = 0x00000000;
//   pico->WriteStream(stream, cmd, 16);

//   err = pico->WriteStream(stream71, A, SIZE * 4);
//   err = pico->WriteStream(stream72, B, SIZE * 4);
//   printf("%i B available to read from stream73.\n", i=pico->GetBytesAvailable(stream73, true));
//   if (i < 0){
//       fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
//       exit(1);
//   }
//   room = i / 4;
//   tmp = new int[room];
//   err = pico->ReadStream(stream73, tmp, i);
//   if (err < 0) {
//       fprintf(stderr, "ReadStream stream73 error: %s\n", PicoErrors_FullError(err, ibuf, sizeof(ibuf)));
//       exit(1);
//   }
//   printf("%d\r\n", room);
//   for (i = 0; i < room; i++) {
//     printf("[%d] 0x%08x\r\n", i, tmp[i]);
//   }

//   printf("%i B available to read from stream.\n", i=pico->GetBytesAvailable(stream, true));
//   if (i < 0){
//       fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
//       exit(1);
//   }
//   room = i / 4;
//   tmp = new int[room];
//   pico->ReadStream(stream, tmp, i);
//   printf("%d\r\n", room);
//   for (i = 0; i < room; i++) {
//     printf("[%d] 0x%08x\r\n", i, tmp[i]);
//   }
//   delete[] tmp;
//==============================================================================
//       _    ____ ____        ___
//      / \  / ___/ ___|  _   ( _ )
//     / _ \| |  | |     (_)  / _ \
//    / ___ \ |__| |___   _  | (_) |
//   /_/   \_\____\____| (_)  \___/
//==============================================================================
  // printf("Opening stream81 (CMD)\r\n");
  // stream81 = pico->CreateStream(81);
  // if (stream81 < 0) {
  //     fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream81, ibuf, sizeof(ibuf)));
  //     exit(1);
  // }

  // printf("Opening stream82 (CMD)\r\n");
  // stream82 = pico->CreateStream(82);
  // if (stream82 < 0) {
  //     fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream82, ibuf, sizeof(ibuf)));
  //     exit(1);
  // }

  // printf("Opening stream83 (CMD)\r\n");
  // stream83 = pico->CreateStream(83);
  // if (stream83 < 0) {
  //     fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream83, ibuf, sizeof(ibuf)));
  //     exit(1);
  // }

  // node   = 8;
  // cmd[3] = 0xBABEFACE;
  // cmd[2] = 0xDEADBEEF;
  // cmd[1] = 0xDEADBEEF;
  // cmd[0] = 0xD000BEEF | (node << 24); // PR Start CMD
  // printf("0x%08x\r\n", cmd[0]);
  // pico->WriteStream(stream, cmd, 16);

  // cmd[0] = 0xD000DEAD | (node << 24); // PR End CMD
  // printf("0x%08x\r\n", cmd[0]);
  // pico->WriteStream(stream, cmd, 16);

  // cmd[0] = 0xC8100000 | (SIZE >> 16) ;
  // cmd[1] = 0xC8200000 | (SIZE & 0x0000FFFF) ;
  // cmd[2] = 0xC8300001;
  // cmd[3] = 0xB8000000;
  // pico->WriteStream(stream, cmd, 16);

  // printf("Lanching ACC\r\n");
  // cmd[0] = 0xA8000000;
  // cmd[1] = 0x00000000;
  // cmd[2] = 0x00000000;
  // cmd[3] = 0x00000000;
  // pico->WriteStream(stream, cmd, 16);

  // err = pico->WriteStream(stream81, A, SIZE * 4);
  // err = pico->WriteStream(stream82, B, SIZE * 4);
  // printf("%i B available to read from stream83.\n", i=pico->GetBytesAvailable(stream83, true));
  // if (i < 0){
  //     fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
  //     exit(1);
  // }
  // room = i / 4;
  // tmp = new int[room];
  // err = pico->ReadStream(stream83, tmp, i);
  // if (err < 0) {
  //     fprintf(stderr, "ReadStream stream83 error: %s\n", PicoErrors_FullError(err, ibuf, sizeof(ibuf)));
  //     exit(1);
  // }
  // printf("%d\r\n", room);
  // // for (i = 0; i < room; i++) {
  // //   printf("[%d] 0x%08x\r\n", i, tmp[i]);
  // // }
  // delete[] tmp;

  // printf("%i B available to read from stream.\n", i=pico->GetBytesAvailable(stream, true));
  // if (i < 0){
  //     fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
  //     exit(1);
  // }
  // room = i / 4;
  // tmp = new int[room];
  // pico->ReadStream(stream, tmp, i);
  // printf("%d\r\n", room);
  // // for (i = 0; i < room; i++) {
  // //   printf("[%d] 0x%08x\r\n", i, tmp[i]);
  // // }
  // delete[] tmp;
//==============================================================================
  printf("Closing stream50 (CMD)\r\n");
  pico->CloseStream(stream);
  // pico->CloseStream(stream11);
  // pico->CloseStream(stream12);
  // pico->CloseStream(stream13);

  // pico->CloseStream(stream21);
  // pico->CloseStream(stream22);
  // pico->CloseStream(stream23);

  // pico->CloseStream(stream31);
  // pico->CloseStream(stream32);
  // pico->CloseStream(stream33);

  // pico->CloseStream(stream41);
  // pico->CloseStream(stream42);
  // pico->CloseStream(stream43);

  // pico->CloseStream(stream51);
  // pico->CloseStream(stream52);
  // pico->CloseStream(stream53);

  // pico->CloseStream(stream61);
  // pico->CloseStream(stream62);
  // pico->CloseStream(stream63);

  // pico->CloseStream(stream71);
  // pico->CloseStream(stream72);
  // pico->CloseStream(stream73);

  // pico->CloseStream(stream81);
  // pico->CloseStream(stream82);
  // pico->CloseStream(stream83);
  printf("Done\r\n");
  delete[] A;
  delete[] B;
  delete[] C;
  delete[] D;
  return 0;
}