foundationdb/fdbserver/workloads/AsyncFile.cpp

/*
 * AsyncFile.cpp
 *
 * This source file is part of the FoundationDB open source project
 *
 * Copyright 2013-2018 Apple Inc. and the FoundationDB project authors
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *     http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "flow/actorcompiler.h"
#include "workloads.h"
#include "flow/ActorCollection.h"

#include "AsyncFile.actor.h"


// class RandomByteGenerator

RandomByteGenerator::RandomByteGenerator(){
	BUF_SIZE = 16*(1<<20);
	b1 = new char[BUF_SIZE];
	for (int i=0;i<BUF_SIZE/sizeof(uint32_t);i++)
		((uint32_t*)b1)[i] = g_random->randomUInt32();
}

RandomByteGenerator::~RandomByteGenerator(){
	delete b1;
}

// only works if buf and bytes are 8-byte aligned
void RandomByteGenerator::writeRandomBytesToBuffer(void *buf, int bytes){
	ASSERT(bytes < BUF_SIZE-1);
	int o1, o2;
	o1 = g_random->randomInt(0, BUF_SIZE-bytes) / 8;
	do {
		o2 = g_random->randomInt(0, BUF_SIZE-bytes) / 8;
	} while (o1==o2);

	int64_t *out64 = (int64_t*)buf;
	int64_t *in64 = (int64_t*)b1;
	int n = bytes/8;
	for (int b=0;b<n;b++)
		out64[b] = in64[o1+b] ^ in64[o2+b];


	//for (int b=0;b<bytes;b++){
		//((char*)buf)[b] = b1[o1+b] ^ b1[o2+b];
	//}
}

//// Asynch File Workload

const int AsyncFileWorkload::_PAGE_SIZE = 4096;

AsyncFileWorkload::AsyncFileWorkload(WorkloadContext const& wcx)
	: TestWorkload(wcx), fileHandle(NULL)
{
	//Only run on one client
	enabled = clientId == 0;
	testDuration = getOption(options, LiteralStringRef("testDuration"), 10.0);
	unbufferedIO = getOption(options, LiteralStringRef("unbufferedIO"), false);
	uncachedIO = getOption(options, LiteralStringRef("uncachedIO"), false);
	fillRandom = getOption(options, LiteralStringRef("fillRandom"), false);
	path = getOption(options, LiteralStringRef("fileName"), LiteralStringRef("")).toString();
}

Reference<AsyncFileBuffer> AsyncFileWorkload::allocateBuffer(size_t size)
{
	return Reference<AsyncFileBuffer>(new AsyncFileBuffer(size, unbufferedIO));
}

Future<bool> AsyncFileWorkload::check(Database const& cx)
{
	return true;
}

//Allocates a buffer of a given size.  If necessary, the buffer will be aligned to 4K
AsyncFileBuffer::AsyncFileBuffer(size_t size, bool aligned)
{
	if(aligned)
	{
#ifdef WIN32
		buffer = (unsigned char*)_aligned_malloc(size, AsyncFileWorkload::_PAGE_SIZE);
#else
		if(posix_memalign((void**)&buffer, AsyncFileWorkload::_PAGE_SIZE, size) != 0)
			buffer = NULL;
#endif
	}
	else
		buffer = (unsigned char*)malloc(size);

	if(buffer == NULL)
	{
		TraceEvent(SevError, "TestFailure").detail("Reason", "Insufficient memory");
		ASSERT(false);
	}

	memset(buffer, 0, size);
	this->aligned = aligned;
}

//Special logic needed here to work with _aligned_malloc on windows
AsyncFileBuffer::~AsyncFileBuffer()
{
#ifdef WIN32
	if(aligned)
	{
		_aligned_free(buffer);
		return;
	}
#endif

	free(buffer);
}

AsyncFileHandle::AsyncFileHandle(Reference<IAsyncFile> file, std::string path, bool temporary)
{
	this->file = file;
	this->path = path;
	this->temporary = temporary;
}

AsyncFileHandle::~AsyncFileHandle()
{
	if(temporary)
		deleteFile(path);
}