char* ReadLine(int fd)
{
char buf[N];
char* result;
int i = 0, bytesRead = 0;
for(; i<N; i++)
{
buf[i] = 0;
}
bytesRead = SafeRead(fd, buf, N);
if(bytesRead <= 0) return NULL;
for(i=0; i<bytesRead; i++)
if(buf[i]=='\n')
{
buf[i]=0;
break;
}
result = malloc(i+1);
if(result==NULL)
FILE_ERR("malloc failed!");
result[i]=0;
memcpy(result, buf, i);
if(-1 == lseek(fd, i - bytesRead + 1, SEEK_CUR))
FILE_ERR("Error occured using lseek in ReadLine function!");
return result;
}
char *genStr(char *filename, int len) {
int fh;
unsigned char *data;
if ((fh = open(filename, O_RDONLY)) == -1) FILE_ERR(filename, "open");
struct stat finfo;
fstat(fh, &finfo);
if ((data = mmap(0, finfo.st_size, PROT_READ, MAP_SHARED, fh, 0))
== MAP_FAILED) FILE_ERR(filename, "mmap");
if (close(fh) == -1) FILE_ERR(filename, "close");
int dataIdx = 0, alphabetSize = 1;
for (; data[dataIdx]; dataIdx += byteLength(data[dataIdx]), ++alphabetSize);
++dataIdx; // we're on the null byte, want to be where data actually starts
if (alphabetSize*alphabetSize*(8+4*alphabetSize) != finfo.st_size - dataIdx) {
return "!!! CORRUPT DATA FILE !!!";
}
char *str = malloc((len+1) * 4*sizeof *str);
int a = alphabetSize - 1, b = alphabetSize - 1;
int strpos = 0;
for (int i = 0; i < len; ++i) {
unsigned char *dataPtr = DATA(a, b);
unsigned long long n = longRand(getLong(dataPtr));
dataPtr += 8;
int nextCharPos = 0;
for (; nextCharPos < alphabetSize; ++nextCharPos) {
unsigned int m = getInt(dataPtr);
if (m > n) break;
n -= m;
dataPtr += 4;
}
a = b;
b = nextCharPos;
int alphabetIdx = 0;
for (; nextCharPos; --nextCharPos) {
alphabetIdx += byteLength(ALPHABET[alphabetIdx]);
}
int nextCharLen = byteLength(ALPHABET[alphabetIdx]);
for (int i = nextCharLen; i >= 0; --i) {
str[strpos + i] = ALPHABET[alphabetIdx + i];
}
strpos += nextCharLen;
}
str[strpos] = '\0';
//for (int i = 0; i < len*2; ++i) printf("str[%d]: %c\n", i, str[i]);
if (munmap(data, finfo.st_size) == -1) FILE_ERR(filename, "munmap");
return str;
}
void work(int info_fd, int log_fd)
{
data pcData = getData();
// Write to info file as binary serialized data
ssize_t charWritten = SafeWrite(info_fd, (char*)&pcData, sizeof(data));
if (charWritten != sizeof(data))
FILE_ERR("Not all data written to info file");
// Write to log file in csv format
char* pdDataText = dataToString(&pcData);
size_t expected_size = strlen(pdDataText)*sizeof(char);
charWritten = SafeWriteLine(log_fd, pdDataText, expected_size);
if (charWritten != expected_size)
FILE_ERR("Not all data written to log file");
free(pdDataText);
}
options* initProgram(int argc, char** argv)
{
// init, get options and init SMC
if(setHandler(sigintHandler, SIGINT))
FILE_ERR("Can't set sigint handler");
options* opt = getOptions(argc, argv);
CHECK_ERROR_WHEN_NULL( opt );
smcInit();
printOptions(opt);
return opt;
}
void prepareFiles(int& info_fd, int& log_fd, options* opt)
{
// Create dir and open info file
CHECK_ERROR( CreateDirIfNotExists(opt->data_dir) );
info_fd = OpenFile(opt->data_file, O_WRONLY | O_APPEND | O_CREAT);
CHECK_ERROR( info_fd );
// Open/Create log file and write column names if file does not exist
bool logCreate = false;
if(-1 == access(opt->log_file, F_OK)) logCreate = true;
log_fd = OpenFile(opt->log_file, O_WRONLY | O_APPEND | O_CREAT);
CHECK_ERROR( log_fd );
if(logCreate)
{
char* data_labels = getDataLabels(',');
size_t data_labels_size = strlen(data_labels)*sizeof(char);
ssize_t data_labels_written = SafeWriteLine(log_fd, data_labels, data_labels_size);
if (data_labels_written != data_labels_size)
FILE_ERR("Not all data labels written to log file");
free(data_labels);
}
}
int index_get(struct index *idx, struct slice *sk, struct slice *sv)
{
int ret = 0, value_len, result;
uint64_t value_off = 0UL;
struct skipnode *node;
struct skiplist *cur_list;
struct skiplist *merge_list;
/*
* 0) Get from bloomfilter, if bloom_get return 1, next
* 1) First lookup from active memtable
* 2) Then from merge memtable
* 3) Last from sst on-disk indexes
*/
cur_list = idx->list;
node = skiplist_lookup(cur_list, sk->data);
if(node) {
if(node->opt == DEL) {
ret = -1;
goto out_get;
}
value_off =node->val;
} else {
merge_list = idx->park->list;
if(merge_list) {
node = skiplist_lookup(merge_list, sk->data);
if(node && node->opt == ADD)
value_off = node->val;
}
}
if(value_off == 0UL)
value_off = sst_getoff(idx->sst, sk);
if(value_off != 0UL) {
__be32 be32len;
lseek(idx->db_rfd, value_off, SEEK_SET);
result = read(idx->db_rfd, &be32len, sizeof(int));
if(FILE_ERR(result)) {
ret = -1;
goto out_get;
}
value_len = from_be32(be32len);
if(result == sizeof(int)) {
char *data = malloc(value_len + 1);
memset(data, 0, value_len+1);
result = read(idx->db_rfd, data, value_len);
if(FILE_ERR(result)) {
free(data);
ret = -1;
goto out_get;
}
sv->len = value_len;
sv->data = data;
return 1;
}
} else {
return 0;
}
out_get:
return ret;
}
