Rename fletch -> dartino

tests/service_tests/performance/performance_test.cc

 // Copyright (c) 2015, the Dartino project authors. Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE.md file.
 
 #include <pthread.h>
 #include <sys/time.h>
 
 #include <cstdio>
 
 #include "include/service_api.h"
-#include "include/fletch_api.h"
+#include "include/dartino_api.h"
 
 #include "src/shared/assert.h"
 #include "src/shared/platform.h"
 
 #include "src/vm/thread_pool.h"
 
 #include "cc/performance_service.h"
 
 static pthread_mutex_t mutex;
 static pthread_cond_t cond;
 static int status = 0;
 
 static const int kDone = 1;
 static const int kCallCount = 10000;
 
-static fletch::Monitor* echo_monitor = fletch::Platform::CreateMonitor();
+static dartino::Monitor* echo_monitor = dartino::Platform::CreateMonitor();
 static bool echo_async_done = false;
 
 static uint64_t GetMicroseconds() {
   struct timeval tv;
   if (gettimeofday(&tv, NULL) < 0) return -1;
   uint64_t result = tv.tv_sec * 1000000LL;
   result += tv.tv_usec;
   return result;
 }
 
@@ skipping 80 matching lines @@
 void EchoInThread(void* data) {
   intptr_t value = reinterpret_cast<intptr_t>(data);
   for (int i = 0; i < 64; i++) {
     int result = PerformanceService::echo(value + i);
     ASSERT(result == value + i);
   }
 }
 
 static void RunThreadTests() {
   const int kThreadCount = 32;
-  fletch::ThreadPool thread_pool(kThreadCount);
+  dartino::ThreadPool thread_pool(kThreadCount);
   thread_pool.Start();
   for (int i = 0; i < kThreadCount; i++) {
     while (!thread_pool.TryStartThread(EchoInThread,
                                        reinterpret_cast<void*>(i))) {
     }
   }
   thread_pool.JoinAll();
 }
 
 static void ChangeStatusAndNotify(int new_status) {
   pthread_mutex_lock(&mutex);
   status = new_status;
   pthread_cond_signal(&cond);
   pthread_mutex_unlock(&mutex);
 }
 
 static void WaitForStatus(int expected) {
   pthread_mutex_lock(&mutex);
   while (expected != status) pthread_cond_wait(&cond, &mutex);
   pthread_mutex_unlock(&mutex);
 }
 
 static void* DartThreadEntry(void* arg) {
   const char* path = static_cast<char*>(arg);
-  FletchSetup();
-  FletchRunSnapshotFromFile(path);
-  FletchTearDown();
+  DartinoSetup();
+  DartinoRunSnapshotFromFile(path);
+  DartinoTearDown();
   ChangeStatusAndNotify(kDone);
   return NULL;
 }
 
 static void RunSnapshotInNewThread(char* path) {
   pthread_t thread;
   int result = pthread_create(&thread, NULL, DartThreadEntry, path);
   if (result != 0) {
     perror("Failed to start thread");
     exit(1);
@@ skipping 19 matching lines @@
     printf("Usage: %s <snapshot>\n", argv[0]);
     return 1;
   }
   SetupPerformanceTest(argc, argv);
   RunEchoTests();
   RunTreeTests();
   RunThreadTests();
   TearDownPerformanceTest();
   return 0;
 }