int main()
{
Stopwatch sw;
sw.restart();
int maxtime = 2;
while(sw.getTime()<maxtime) {
printf("%f \n",sw.getTime());
}
sw.stop();
printf("end time = %f \n",sw.getTime());
}
float BenchmarkCPU::runCPUBenchmark(int iters, int n1, int n2)
{
ArraySumUtil hope;
Stopwatch sw;
//Testing the GPU class
float **h_xx = (float**)malloc(sizeof(float*)*n1);
float **h_yy = (float**)malloc(sizeof(float*)*n1);
for(int i = 0; i<n1; i++) {
h_xx[i] = (float*)malloc(sizeof(float)*n2);
h_yy[i] = (float*)malloc(sizeof(float)*n2);
//Initializing the arrays.
for(int j = 0; j<n2; j++) {
h_xx[i][j] = i+j;
h_yy[i][j] = i+j;
}
}
int maxTime = 5;
int count = 0;
sw.restart();
while (sw.getTime() < maxTime) {
hope.arraySumCPULoop(h_xx, h_yy, n1, n2, iters);
count++;
std::cout << sw.getTime() << std::endl;
}
sw.stop();
float n1f = (float) n1;
float n2f = (float) n2;
float countf = (float) count;
float mflops = n1f*n2f*countf*iters*1.0e-06/sw.getTime();
//std::cout << "Number of MegaFLOPs: " << n1f*n2f*500*countf*1.0e-6 << std::endl;
std::cout << mflops << " MegaFLOPS" << std::endl;
return mflops;
}
bool
CondVarBase::wait(Stopwatch& timer, double timeout) const
{
double remain = timeout-timer.getTime();
// Some ARCH wait()s return prematurely, retry until really timed out
// In particular, ArchMultithreadPosix::waitCondVar() returns every 100ms
do {
// Always call wait at least once, even if remain is 0, to give
// other thread a chance to grab the mutex to avoid deadlocks on
// busy waiting.
if (remain<0.0) remain=0.0;
if (wait(remain))
return true;
remain = timeout - timer.getTime();
} while (remain >= 0.0);
return false;
}
bool
CondVarBase::wait(Stopwatch& timer, double timeout) const
{
// check timeout against timer
if (timeout >= 0.0) {
timeout -= timer.getTime();
if (timeout < 0.0)
return false;
}
return wait(timeout);
}
void InternalThreadEntry() {
Stopwatch timer;
timer.start();
for(int j = 0; j<this->n; j++) {
if(this->A[this->i][j]) {
for(int k = 0; k<this->n; k++) {
if(this->A[this->i][k] && A[j][k]) this->t++;
}
}
}
timer.stop();
this->time = timer.getTime();
}
TestCase * Grader07::testSpellCheck(std::string filename)
{
Commands07 cmds07;
std::vector<std::string> words;
std::vector<SpellCheckCmd> commands;
cmds07.readReads("words", words);
cmds07.loadSpellCheckCommands(filename, commands);
if(words.size() == 0){
return failed("cannot read input file #1");
}
if(commands.size() == 0){
return failed("cannot read input file #2");
}
Stopwatch watch;
watch.start();
ISpellCheck * checker = (ISpellCheck *) createObject("ISpellCheck");
if(checker == NULL){
return nullObject("ISpellCheck");
}
watch.pause();
checker->loadDictionary(words);
watch.unpause();
for(size_t i = 0; i < commands.size(); ++i){
SpellCheckCmd cmd = commands[i];
std::vector<std::string> product_corrections = checker->suggestCorrections(cmd.word);
watch.pause();
std::sort(product_corrections.begin(), product_corrections.end());
if(product_corrections != cmd.corrections){
return failed("corrections mismatch");
}
watch.unpause();
}
watch.stop();
return passed(watch.getTime());
}
TestCase * Grader07::testStringSearch(std::string cmds_filename, std::string input_filename)
{
std::vector<StringSearchCmd> commands;
Commands07 cmds07;
cmds07.loadStringSearchCommmands(cmds_filename, commands);
std::string to_search = cmds07.readStringFile(input_filename);
if(commands.size() == 0){
return failed("cannot read input file #1");
}
if(to_search == ""){
return failed("cannot read input file #2");
}
Stopwatch watch;
watch.start();
IStringSearch * searcher = (IStringSearch *) createObject("IStringSearch");
if(searcher == NULL){
return nullObject("IStringSearch");
}
watch.pause();
searcher->prepareText(to_search);
watch.unpause();
for(size_t i = 0; i < commands.size(); ++i){
StringSearchCmd cmd = commands[i];
std::vector<int> product_results = searcher->search(cmd.to_find);
if(product_results.size() != cmd.positions.size()){
return failed("incorrect return size");
}
std::sort(product_results.begin(), product_results.end());
if(product_results != cmd.positions){
return failed("at least one incorrect return index");
}
}
watch.stop();
return passed(watch.getTime());
}
TestCase * Grader07::testCompress(std::string input_filename, std::string output_filename)
{
Commands07 cmds07;
std::string input = cmds07.readStringFile(input_filename);
Stopwatch watch;
watch.start();
ICompress * compressor = (ICompress *) createObject("ICompress");
if(compressor == NULL){
return nullObject("ICompress");
}
std::string output = compressor->compress(input);
watch.stop();
cmds07.writeStringFile(output_filename, output);
return passed(watch.getTime()+output.size());
}
TestCase * Grader07::testStringSort(std::string input_filename)
{
std::vector<std::string> input;
std::vector<std::string> output;
Commands07 cmds07;
cmds07.readReads(input_filename, input);
cmds07.readReads(input_filename, output);
if(input.size() == 0){
return failed("cannot read input file #1");
}
if(output.size() == 0){
return failed("cannot read input file #2");
}
Stopwatch watch;
watch.start();
IStringSort * sorter = (IStringSort *) createObject("IStringSort");
if(sorter == NULL){
return nullObject("IStringSort");
}
sorter->sort(input);
watch.stop();
std::sort(output.begin(), output.end());
if(input.size() != output.size()){
return failed("incorrect size");
}
if(input != output){
return failed("at least one incorrect string");
}
return passed(watch.getTime());
}
TestCase * Grader07::testDecompress(std::string input_filename, std::string output_filename)
{
Commands07 cmds07;
std::string input = cmds07.readStringFile(input_filename);
std::string gold_output = cmds07.readStringFile(output_filename);
Stopwatch watch;
watch.start();
ICompress * compressor = (ICompress *) createObject("ICompress");
if(compressor == NULL){
return nullObject("ICompress");
}
std::string output = compressor->decompress(input);
watch.stop();
if(gold_output != output){
return failed("results do not match");
}
return passed(watch.getTime());
}
int main() {
for(int n=5; n<=200; n+=5) {
printf("\n%d iterations\n", n);
printf("---------------------------------\n");
int t = 0;
matrix A = initializeMatrix(n,n);
Triangles* workers = new Triangles[n];
Stopwatch timer;
timer.start();
for(int x = 0; x<n; x++) {
workers[x].setParameters(x, n, A);
if(!workers[x].StartInternalThread()) {
printf("Err pthread_create for thread %d \n", x+1);
}
}
for(int x=0; x<n; x++) {
workers[x].WaitForInternalThreadToExit();
t += workers[x].getResult();
}
t /= 3;
timer.stop();
float averageTime = [](Triangles* w, int n)->float {
float sum = 0;
for(int x = 0; x<n; x++) {
sum += w[x].getTime();
}
return sum/n;
}(workers, n);
float maxTime = [](Triangles* w, int n)->float {
float max = 0;
for(int x = 0; x<n; x++) {
if(w[x].getTime() > max) {
max = w[x].getTime();
}
}
return max;
}(workers, n);
float minTime = [](Triangles* w, int n)->float {
float min = w[0].getTime();
for(int x = 1; x<n; x++) {
if(w[x].getTime() < min) {
min = w[x].getTime();
}
}
return min;
}(workers, n);
float linearTime = [](Triangles* w, int n)->float {
float sum = 0;
for(int x = 0; x<n; x++) {
sum += w[x].getTime();
}
return sum;
}(workers, n);
float overallTime = timer.getTime();
printf("All tasks ended succesfully\n");
printf("Found %d triangles \n", t);
printf("Average search time:\t %.0f \n", averageTime);
printf("Max search time:\t %.0f \n", maxTime);
printf("Min search time:\t %.0f \n", minTime);
printf("Linear approximate time: %.0f \n", linearTime);
printf("Overall search time:\t %.0f\n", overallTime);
printf("---------------------------------\n");
}
getchar();
return 0;
}
int main (int argc, const char * argv[]){
//Declaring Variables for for loops
int minIters = 2;
int maxIters = 32768;
int minSize = 500;
int maxSize = 2500;
int a = 0;
int b = 0;
cl_platform_id platform;
cl_device_id device;
cl_context context;
cl_command_queue queue;
cl_program program;
cl_kernel kernel;
//A cl_int used to store error flags that are returned if OpenCL function does not execute properly
cl_int err;
const char* fileName;
const char* kernelName;
FILE *program_handle;
char *program_buffer, *program_log;
size_t program_size, log_size;
std::string programLog;
//The number of work items in each dimension of the data.
size_t work_units_per_kernel;
Stopwatch sw;
//Outer most loop: This loop should encompass all code and is used in order to loop over
//different values of the iterations and array size to create the data for the plot.
for(int i = minSize; i < maxSize; i+=100){
std::cout << "Array Size: " << i << std::endl;
for(int j = minIters; j < maxIters; j*=2){
std::cout << "Iterations: " << j << std::endl;
//TODO: Move lower in the code
//data[a][b] = datagpu.runGPUBenchmark(10, 3, 3);
//Initializing the arrays
int n1 = i;
int n2 = i+1;
int iters = j;
long dims = n1*n2;
float **h_xx = new float*[n1];
float **h_yy = new float*[n1];
float **h_zz = new float*[n1];
for(int x = 0; x<n1; x++){
h_xx[x] = new float [n2];
h_yy[x] = new float [n2];
h_zz[x] = new float [n2];
//Initializing the arrays.
for(int y = 0; y<n2; y++){
h_xx[x][y] = x+y;
h_yy[x][y] = x+y;
}
}
//Here the benchmark occurs. Within this while loop must occurr all OpenCL calls and executions
int maxTime = 5;
int count = 0;
sw.restart();
while (sw.getTime() < maxTime){
err = clGetPlatformIDs(1, &platform, NULL);
if (err != CL_SUCCESS){
std::cout << "Error: Failed to locate the platform." << std::endl;
exit(1);
}
err = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 1, &device, NULL);
if(err != CL_SUCCESS){
std::cout << "Error: Failed to locate the device." << std::endl;
exit(1);
}
context = clCreateContext(NULL, 1, &device, NULL, NULL, &err);
if(err != CL_SUCCESS){
std::cout << "Error: Could not create a context." << std::endl;
exit(1);
}
program_handle = fopen("floptmem.cl", "r");
if(!program_handle){
std::cout << "Error: Failed to load Kernel" << std::endl;
exit(1);
}
fseek(program_handle, 0, SEEK_END);
program_size = ftell(program_handle);
rewind(program_handle);
program_buffer = (char*)malloc(program_size + 1);
program_buffer[program_size] = '\0';
fread(program_buffer, sizeof(char), program_size, program_handle);
fclose(program_handle);
program = clCreateProgramWithSource(context, 1, (const char **)&program_buffer, (const size_t *)&program_size, &err);
if(err != CL_SUCCESS){
std::cout << "Error: Could not create the program" << std::endl;
exit(1);
}
err = clBuildProgram(program, 1, &device, NULL, NULL, NULL);
if(err != CL_SUCCESS){
std::cout << "Error: Could not compile the program" << std::endl;
clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG, 0, NULL, &log_size);
program_log = (char*)malloc(log_size+1);
program_log[log_size] = '\0';
clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG, log_size+1, program_log, NULL);
programLog = program_log;
std::cout << programLog << std::endl;
free(program_log);
exit(1);
}
kernel = clCreateKernel(program, "arraysum", &err);
if(err != CL_SUCCESS){
std::cout << "Error: Could not create the kernel." << std::endl;
exit(1);
}
queue = clCreateCommandQueue(context, device, 0, &err);
if(err != CL_SUCCESS){
std::cout << "Error: Could not create the queue." << std::endl;
exit(1);
}
cl_mem d_xx, d_yy, d_zz;
d_xx = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(float)*dims, NULL, &err);
if(err != CL_SUCCESS){
std::cout << "Error: Could not create the buffer." << std::endl;
exit(1);
}
d_yy = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(float)*dims, NULL, &err);
if(err != CL_SUCCESS){
std::cout << "Error: Could not create the buffer." << std::endl;
exit(1);
}
d_zz = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(float)*dims, NULL, &err);
if(err != CL_SUCCESS){
std::cout << "Error: Could not create the buffer." << std::endl;
exit(1);
}
float *h_xx1 = new float[dims];
float *h_yy1 = new float[dims];
float *h_zz1 = new float[dims];
//packing arrays
int k = 0;
for (int x = 0; x < n1; x++){
for (int y = 0; y < n2; y++){
h_xx1[k] = h_xx[x][y];
h_yy1[k] = h_yy[x][y];
k++;
}
}
err = clEnqueueWriteBuffer(queue, d_xx, CL_FALSE, 0, sizeof(float)*dims, h_xx1, 0, NULL, NULL);
if(err != CL_SUCCESS){
std::cout << "Error: Could not write to buffer." << std::endl;
exit(1);
}
err = clEnqueueWriteBuffer(queue, d_yy, CL_FALSE, 0, sizeof(float)*dims, h_yy1, 0, NULL, NULL);
if(err != CL_SUCCESS){
std::cout << "Error: Could not write to buffer." << std::endl;
exit(1);
}
err = clSetKernelArg(kernel, 0, sizeof(cl_mem), &d_xx);
if(err != CL_SUCCESS){
std::cout << "Error: Could not set the kernel argument." << std::endl;
std::cout << "OpenCL error code: " << err << std::endl;
exit(1);
}
err = clSetKernelArg(kernel, 1, sizeof(cl_mem), &d_yy);
if(err != CL_SUCCESS){
std::cout << "Error: Could not set the kernel argument." << std::endl;
std::cout << "OpenCL error code: " << err << std::endl;
exit(1);
}
err = clSetKernelArg(kernel, 2, sizeof(cl_mem), &d_zz);
if(err != CL_SUCCESS){
std::cout << "Error: Could not set the kernel argument." << std::endl;
std::cout << "OpenCL error code: " << err << std::endl;
exit(1);
}
err = clSetKernelArg(kernel, 3, sizeof(j), &j);
if(err != CL_SUCCESS){
std::cout << "Error: Could not set the integer kernel argument." << std::endl;
std::cout << "OpenCL error code: " << err << std::endl;
exit(1);
}
work_units_per_kernel = dims;
err = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, &work_units_per_kernel, NULL, 0, NULL, NULL);
if(err != CL_SUCCESS){
std::cout << "Error: Could not execute the kernel." << std::endl;
exit(1);
}
err = clEnqueueReadBuffer(queue, d_zz, CL_TRUE, 0, sizeof(float)*dims, h_zz1, 0, NULL, NULL);
if(err != CL_SUCCESS){
std::cout << "Error: Could not read data from the kernel." << std::endl;
std::cout << "OpenCL error code: " << std::endl;
exit(1);
}
//unpacking the 1D array
k = 0;
for (int x = 0; x < n1; x++){
for (int y = 0; y < n2; y++){
h_zz[x][y] = h_zz1[k];
k++;
}
}
delete [] h_xx1;
delete [] h_yy1;
delete [] h_zz1;
count++;
//Freeing up memory. Hopefully!
clReleaseMemObject(d_xx);
clReleaseMemObject(d_yy);
clReleaseMemObject(d_zz);
clReleaseKernel(kernel);
clReleaseCommandQueue(queue);
clReleaseProgram(program);
clReleaseContext(context);
}
sw.stop();
for (int x = 0; x < n1; x++)
{
delete [] h_xx[x];
delete [] h_yy[x];
delete [] h_zz[x];
}
delete [] h_xx;
delete [] h_yy;
delete [] h_zz;
float n1f = (float) n1;
float n2f = (float) n2;
float countf = (float) count;
std::cout << "n1: " << n1f << std::endl;
std::cout << "n2: " << n2f << std::endl;
std::cout << "Iters: " << iters << std::endl;
std::cout << "count: " << countf << std::endl;
std::cout << "Time: " << sw.getTime() << std::endl;
std::cout << std::endl;
float mflops = n1f*n2f*countf*iters*1.0e-06/sw.getTime();
//std::cout << "Number of MegaFLOPs: " << n1f*n2f*500*countf*1.0e-6 << std::endl;
std::cout << mflops << " MegaFLOPS" << std::endl;
b++;
}
a++;
std::cout << std::endl;
}
return 0;
}
TestCase * Grader02::testWorkload4(int len, int order, int merge_count,
int merge_len){
std::vector<int> input;
std::vector<int> sorted;
createVector(input, sorted, order, len, false);
Stopwatch watch;
watch.start();
IPriorityQueue * queue = (IPriorityQueue *)createObject("IPriorityQueue4");
if (queue == NULL){
return nullObject("IPriorityQueue4");
}
watch.pause();
GoldPriorityQueue gold_queue(sorted);
for (size_t i = 0; i < merge_len; ++i){
int key = input[i];
std::string value = randomValue();
gold_queue.push_back(key, value);
watch.unpause();
IKeyValue * key_value = (IKeyValue *)createObject("IKeyValue4");
if (key_value == NULL){
return nullObject("IKeyValue4");
}
key_value->setKey(key);
key_value->setValue(value);
queue->enqueue(key_value);
int size = queue->size();
if (size != gold_queue.size()){
return failed("after enqueue, size is incorrect");
}
int user_key = queue->lowestKey();
IVectorString * user_values = queue->lowestValues();
gold_queue.iterate();
int gold_key = gold_queue.lowestKey();
std::vector<std::string> values = gold_queue.getValues(gold_key);
watch.pause();
if (gold_key != user_key){
return failed("after enqueue, lowest key is incorrect");
}
if (valuesEqual(user_values, values) == false){
return failed("after enqueue, values incorrect");
}
}
for (int i = 1; i < merge_count; ++i){
watch.unpause();
IPriorityQueue * queue2 = (IPriorityQueue *)createObject("IPriorityQueue4");
if (queue == NULL){
return nullObject("IPriorityQueue4");
}
watch.pause();
for (int j = (i * merge_len); j < ((i + 1) * merge_len); ++j){
int key = input[j];
std::string value = randomValue();
gold_queue.push_back(key, value);
watch.unpause();
IKeyValue * key_value = (IKeyValue *)createObject("IKeyValue4");
if (key_value == NULL){
return nullObject("IKeyValue4");
}
key_value->setKey(key);
key_value->setValue(value);
queue2->enqueue(key_value);
watch.pause();
}
watch.unpause();
queue->merge(queue2);
watch.pause();
gold_queue.iterate();
watch.unpause();
int user_key = queue->lowestKey();
IVectorString * user_values = queue->lowestValues();
watch.pause();
int gold_key = gold_queue.lowestKey();
std::vector<std::string> values = gold_queue.getValues(gold_key);
if (gold_key != user_key){
return failed("during dequeue, lowest key is incorrect");
}
if (valuesEqual(user_values, values) == false){
return failed("during dequeue, values incorrect");
}
}
return passed(watch.getTime());
}
int main(void)
{
//std::cout << "Generating a time series on device "<< tim.get_nsamps() << std::endl;
//DeviceTimeSeries<float> d_tim(8388608);
//d_tim.set_tsamp(0.000064);
TimeSeries<float> tim;
tim.from_file("/lustre/home/ebarr/Soft/peasoup/tmp5.tim");
DeviceTimeSeries<float> d_tim(tim);
unsigned int size = d_tim.get_nsamps();
TimeSeriesFolder folder(size);
//DeviceTimeSeries<float> d_tim_r(fft_size); //<----for resampled data
//TimeDomainResampler resampler;
float* folded_buffer;
cudaError_t error;
cufftResult result;
error = cudaMalloc((void**)&folded_buffer, sizeof(float)*size);
ErrorChecker::check_cuda_error(error);
unsigned nints = 64;
unsigned nbins = 32;
cufftComplex* fft_out;
error = cudaMalloc((void**)&fft_out, sizeof(cufftComplex)*nints*nbins);
cufftHandle plan;
result = cufftPlan1d(&plan,nbins,CUFFT_R2C, nints);
ErrorChecker::check_cufft_error(result);
Stopwatch timer;
FoldedSubints<float> folded_array(nbins,nints);
//folder.fold(d_tim,folded_array,0.007453079228);
std::cout << "made it here" << std::endl;
FoldOptimiser optimiser(nbins,nints);
timer.start();
for (int ii=0;ii<1;ii++){
//FoldedSubints<float> folded_array(nbins,nints);
folder.fold(d_tim,folded_array,0.007453099228);
Utils::dump_device_buffer<float>(folded_array.get_data(),nints*nbins,"original_fold.bin");
optimiser.optimise(folded_array);
}
timer.stop();
/*
float* temp = new float [nints*nbins];
cudaMemcpy(temp,folded_buffer,nints*nbins*sizeof(float),cudaMemcpyDeviceToHost);
ErrorChecker::check_cuda_error();
for (int ii=0;ii<nints*nbins;ii++)
std::cout << temp[ii] << std::endl;
*/
std::cout << "Total execution time (s): " << timer.getTime()<<std::endl;
std::cout << "Average execution time (s): " << timer.getTime()/1000.0 << std::endl;
return 0;
}
int
FileChunk::assemble(synergy::IStream* stream, String& dataReceived, size_t& expectedSize)
{
// parse
UInt8 mark = 0;
String content;
static size_t receivedDataSize;
static double elapsedTime;
static Stopwatch stopwatch;
if (!ProtocolUtil::readf(stream, kMsgDFileTransfer + 4, &mark, &content)) {
return kError;
}
switch (mark) {
case kDataStart:
dataReceived.clear();
expectedSize = synergy::string::stringToSizeType(content);
receivedDataSize = 0;
elapsedTime = 0;
stopwatch.reset();
if (CLOG->getFilter() >= kDEBUG2) {
LOG((CLOG_DEBUG2 "recv file data from client: file size=%s", content.c_str()));
stopwatch.start();
}
return kStart;
case kDataChunk:
dataReceived.append(content);
if (CLOG->getFilter() >= kDEBUG2) {
LOG((CLOG_DEBUG2 "recv file data from client: chunck size=%i", content.size()));
double interval = stopwatch.getTime();
receivedDataSize += content.size();
LOG((CLOG_DEBUG2 "recv file data from client: interval=%f s", interval));
if (interval >= kIntervalThreshold) {
double averageSpeed = receivedDataSize / interval / 1000;
LOG((CLOG_DEBUG2 "recv file data from client: average speed=%f kb/s", averageSpeed));
receivedDataSize = 0;
elapsedTime += interval;
stopwatch.reset();
}
}
return kNotFinish;
case kDataEnd:
if (expectedSize != dataReceived.size()) {
LOG((CLOG_ERR "corrupted clipboard data, expected size=%d actual size=%d", expectedSize, dataReceived.size()));
LOG((CLOG_NOTIFY "File Transmission Failed: Corrupted file data."));
return kError;
}
if (CLOG->getFilter() >= kDEBUG2) {
LOG((CLOG_DEBUG2 "file data transfer finished"));
elapsedTime += stopwatch.getTime();
double averageSpeed = expectedSize / elapsedTime / 1000;
LOG((CLOG_DEBUG2 "file data transfer finished: total time consumed=%f s", elapsedTime));
LOG((CLOG_DEBUG2 "file data transfer finished: total data received=%i kb", expectedSize / 1000));
LOG((CLOG_DEBUG2 "file data transfer finished: total average speed=%f kb/s", averageSpeed));
}
return kFinish;
}
return kError;
}
void
StreamChunker::sendClipboard(
String& data,
size_t size,
ClipboardID id,
UInt32 sequence,
IEventQueue* events,
void* eventTarget)
{
s_isChunkingClipboard = true;
// send first message (data size)
String dataSize = synergy::string::sizeTypeToString(size);
ClipboardChunk* sizeMessage = ClipboardChunk::start(id, sequence, dataSize);
events->addEvent(Event(events->forClipboard().clipboardSending(), eventTarget, sizeMessage));
// send clipboard chunk with a fixed size
size_t sentLength = 0;
size_t chunkSize = s_chunkSize;
Stopwatch keepAliveStopwatch;
Stopwatch sendStopwatch;
keepAliveStopwatch.start();
sendStopwatch.start();
while (true) {
if (s_interruptClipboard) {
s_interruptClipboard = false;
LOG((CLOG_NOTIFY "clipboard transmission interrupted"));
break;
}
if (keepAliveStopwatch.getTime() > KEEP_ALIVE_THRESHOLD) {
events->addEvent(Event(events->forFile().keepAlive(), eventTarget));
keepAliveStopwatch.reset();
}
if (sendStopwatch.getTime() > SEND_THRESHOLD) {
// make sure we don't read too much from the mock data.
if (sentLength + chunkSize > size) {
chunkSize = size - sentLength;
}
String chunk(data.substr(sentLength, chunkSize).c_str(), chunkSize);
ClipboardChunk* dataChunk = ClipboardChunk::data(id, sequence, chunk);
events->addEvent(Event(events->forClipboard().clipboardSending(), eventTarget, dataChunk));
sentLength += chunkSize;
if (sentLength == size) {
break;
}
sendStopwatch.reset();
}
}
// send last message
ClipboardChunk* end = ClipboardChunk::end(id, sequence);
events->addEvent(Event(events->forClipboard().clipboardSending(), eventTarget, end));
s_isChunkingClipboard = false;
}
void
StreamChunker::sendFile(
char* filename,
IEventQueue* events,
void* eventTarget)
{
s_isChunkingFile = true;
std::fstream file(reinterpret_cast<char*>(filename), std::ios::in | std::ios::binary);
if (!file.is_open()) {
throw runtime_error("failed to open file");
}
// check file size
file.seekg (0, std::ios::end);
size_t size = (size_t)file.tellg();
// send first message (file size)
String fileSize = synergy::string::sizeTypeToString(size);
FileChunk* sizeMessage = FileChunk::start(fileSize);
events->addEvent(Event(events->forFile().fileChunkSending(), eventTarget, sizeMessage));
// send chunk messages with a fixed chunk size
size_t sentLength = 0;
size_t chunkSize = s_chunkSize;
Stopwatch keepAliveStopwatch;
Stopwatch sendStopwatch;
keepAliveStopwatch.start();
sendStopwatch.start();
file.seekg (0, std::ios::beg);
while (true) {
if (s_interruptFile) {
s_interruptFile = false;
LOG((CLOG_NOTIFY "file transmission interrupted"));
break;
}
if (keepAliveStopwatch.getTime() > KEEP_ALIVE_THRESHOLD) {
events->addEvent(Event(events->forFile().keepAlive(), eventTarget));
keepAliveStopwatch.reset();
}
if (sendStopwatch.getTime() > SEND_THRESHOLD) {
// make sure we don't read too much from the mock data.
if (sentLength + chunkSize > size) {
chunkSize = size - sentLength;
}
char* chunkData = new char[chunkSize];
file.read(chunkData, chunkSize);
UInt8* data = reinterpret_cast<UInt8*>(chunkData);
FileChunk* fileChunk = FileChunk::data(data, chunkSize);
delete[] chunkData;
events->addEvent(Event(events->forFile().fileChunkSending(), eventTarget, fileChunk));
sentLength += chunkSize;
file.seekg (sentLength, std::ios::beg);
if (sentLength == size) {
break;
}
sendStopwatch.reset();
}
}
// send last message
FileChunk* end = FileChunk::end();
events->addEvent(Event(events->forFile().fileChunkSending(), eventTarget, end));
file.close();
s_isChunkingFile = false;
}
TestCase * Grader02::testWorkload1(int len, int order){
std::vector<int> input;
std::vector<int> sorted;
createVector(input, sorted, order, len, true);
Stopwatch watch;
watch.start();
IPriorityQueue * queue = (IPriorityQueue *)createObject("IPriorityQueue1");
if (queue == NULL){
return nullObject("IPriorityQueue1");
}
watch.pause();
GoldPriorityQueue gold_queue(sorted);
for (size_t i = 0; i < input.size(); ++i){
int key = input[i];
std::string value = randomValue();
gold_queue.push_back(key, value);
watch.unpause();
IKeyValue * key_value = (IKeyValue *)createObject("IKeyValue1");
if (key_value == NULL){
return nullObject("IKeyValue1");
}
key_value->setKey(key);
key_value->setValue(value);
queue->enqueue(key_value);
int size = queue->size();
if (size != gold_queue.size()){
return failed("after enqueue, size is incorrect");
}
int user_key = queue->lowestKey();
IVectorString * user_values = queue->lowestValues();
gold_queue.iterate();
int gold_key = gold_queue.lowestKey();
std::vector<std::string> values = gold_queue.getValues(gold_key);
watch.pause();
if (gold_key != user_key){
return failed("after enqueue, lowest key is incorrect");
}
if (valuesEqual(user_values, values) == false){
return failed("after enqueue, values incorrect");
}
bool check_sort = true;
if (len != 10 && i % 100 != 0){
check_sort = false;
}
if (check_sort){
watch.unpause();
IVectorKeyValue * user_sorted = queue->returnSorted();
watch.pause();
if (sortedEqual(user_sorted, gold_queue.returnSorted()) == false){
return failed("after enqueue, sorted is not equal");
}
}
}
gold_queue.iterate();
int count = 0;
while (gold_queue.hasNext()){
watch.unpause();
int user_key = queue->lowestKey();
IVectorString * user_values = queue->lowestValues();
watch.pause();
int gold_key = gold_queue.lowestKey();
std::vector<std::string> values = gold_queue.getValues(gold_key);
if (gold_key != user_key){
return failed("during dequeue, lowest key is incorrect");
}
if (valuesEqual(user_values, values) == false){
return failed("during dequeue, values incorrect");
}
watch.unpause();
int size = queue->size();
watch.pause();
if (size != gold_queue.size()){
return failed("during dequeue, size is incorrect");
}
bool check_sort = true;
if (len != 10 && count % 100 != 0){
check_sort = false;
}
if (check_sort){
IVectorKeyValue * user_sorted = queue->returnSorted();
std::vector<std::pair<int, std::string> > gold_sorted = gold_queue.returnSorted();
if (sortedEqual(user_sorted, gold_sorted) == false){
return failed("during dequeue, sorted is not equal");
}
}
watch.unpause();
queue->dequeue();
watch.pause();
gold_queue.dequeue();
++count;
}
return passed(watch.getTime());
}