/**
* Read a trace record from the trace buffer
*
* @idx Trace buffer index
* @record Trace record to fill
*
* Returns false if the record is not valid.
*/
static bool get_trace_record(unsigned int idx, TraceRecord **recordptr)
{
uint64_t event_flag = 0;
TraceRecord record;
/* read the event flag to see if its a valid record */
read_from_buffer(idx, &record, sizeof(event_flag));
if (!(record.event & TRACE_RECORD_VALID)) {
return false;
}
smp_rmb(); /* read memory barrier before accessing record */
/* read the record header to know record length */
read_from_buffer(idx, &record, sizeof(TraceRecord));
*recordptr = malloc(record.length); /* don't use g_malloc, can deadlock when traced */
/* make a copy of record to avoid being overwritten */
read_from_buffer(idx, *recordptr, record.length);
smp_rmb(); /* memory barrier before clearing valid flag */
(*recordptr)->event &= ~TRACE_RECORD_VALID;
/* clear the trace buffer range for consumed record otherwise any byte
* with its MSB set may be considered as a valid event id when the writer
* thread crosses this range of buffer again.
*/
clear_buffer_range(idx, record.length);
return true;
}
const Byte* Problem::unpack(const Byte* buffer)
{
const Byte* cursor = buffer;
cursor = mesh_ptr->unpack(cursor);
cursor = read_from_buffer(fa,cursor);
cursor = read_from_buffer(fb,cursor);
cursor = read_from_buffer(rhs_func,cursor);
cursor = read_from_buffer(num_jobs, cursor);
return cursor;
}
static size_t
input_curl_read(struct input_stream *is, void *ptr, size_t size,
GError **error_r)
{
struct input_curl *c = (struct input_curl *)is;
bool success;
size_t nbytes = 0;
char *dest = ptr;
do {
/* fill the buffer */
success = fill_buffer(is, error_r);
if (!success)
return 0;
/* send buffer contents */
while (size > 0 && !g_queue_is_empty(c->buffers)) {
size_t copy = read_from_buffer(&c->icy_metadata, c->buffers,
dest + nbytes, size);
nbytes += copy;
size -= copy;
}
} while (nbytes == 0);
if (icy_defined(&c->icy_metadata))
copy_icy_tag(c);
is->offset += (goffset)nbytes;
return nbytes;
}
void handle_client(int cfd){
char name[1024];
bzero(name, 1024);
read (cfd, &name, 1024);
printf("%s\n", name);
int fret = open(name, O_RDONLY);
if (fret < 0){
//perror("file error");
write(cfd, "ER", 2);
char* err = strerror(errno);
write(cfd, err, strlen(err));
printf("%s", err);
close(cfd);
return;
}
printf("asdfasdfsaf\n");
write(cfd, "OK", 2);
struct stat stat_src;
fstat(fret, &stat_src);
size_t num = htons(stat_src.st_size);
printf("sending file size: %d\n", stat_src.st_size);
write(cfd, &num, sizeof(num));
s_buffer* buf = alloc_buffer(256, fret, cfd);
int bufret = 1;
while(bufret > 0){
bufret = read_to_buf(buf, fret);
bufret = read_from_buffer(buf, cfd);
}
dealloc_buffer(buf);
close(cfd);
}
unsigned int mpeg_idle(mpeg_struct_t *Mpeg_Struct, new_screen* ScreenBuff, FileInfo_t *mpgfile)
{
if(!Mpeg_Struct) return 0;
if(!Mpeg_Struct->FrameReady)
{
do
{
Mpeg_Struct->state = mpeg2_parse(Mpeg_Struct->decoder);
switch (Mpeg_Struct->state)
{
case STATE_BUFFER:
//size = fread (buffer, 1, _BUFFER_SIZE_, mpgfile);
Mpeg_Struct->size = read_from_buffer(Mpeg_Struct->buffer, 1, _BUFFER_SIZE_, mpgfile);
if(!Mpeg_Struct->size) break;
mpeg2_buffer (Mpeg_Struct->decoder, Mpeg_Struct->buffer, Mpeg_Struct->buffer + Mpeg_Struct->size);
break;
case STATE_SEQUENCE:
mpeg2_convert (Mpeg_Struct->decoder, Mpeg_Struct->mpeg_convert, NULL);
break;
case STATE_SLICE:
case STATE_END:
case STATE_INVALID_END:
if (Mpeg_Struct->info->display_fbuf) Mpeg_Struct->FrameReady = 1;
break;
default:
break;
}
}while(!Mpeg_Struct->FrameReady && Mpeg_Struct->size);
}
#ifndef AVR32
if(Mpeg_Struct->FrameReady == true && (timer_tick(&Mpeg_Struct->FrameDisplay) == true || Mpeg_Struct->EnableFrameLimit == false))
#else
if(Mpeg_Struct->FrameReady == true)
#endif
{
Mpeg_Struct->FrameReady = false;
/*save_ppm (ScreenBuff, Mpeg_Struct->info->sequence->width, Mpeg_Struct->info->sequence->height,
Mpeg_Struct->info->display_fbuf->buf[0], Mpeg_Struct->framenum++);*/
_Fps++;
//Mpeg_Struct->->info
if(Mpeg_Struct->info->current_picture->temporal_reference != Mpeg_Struct->temporal_reference)
{
Mpeg_Struct->temporal_reference = Mpeg_Struct->info->current_picture->temporal_reference;
Mpeg_Struct->CallbackDisplayFrame((void*)Mpeg_Struct->CallbackDisplayFrameVariable, Mpeg_Struct->info->display_fbuf->buf[0], 0, 0, Mpeg_Struct->info->sequence->width, Mpeg_Struct->info->sequence->height);
}
if(CntToDetermineTheFps != rtcSecUpdate)
{
CntToDetermineTheFps = rtcSecUpdate;
//UARTPuts(DebugCom, "Screen fill capability = ", -1);
UARTPutNum(DebugCom, _Fps);
UARTPuts(DebugCom, "Fps\n\r", -1);
_Fps = 0;
}
}
//if(Mpeg_Struct->size == 0) mpeg2_close (Mpeg_Struct->decoder);
return Mpeg_Struct->size;
}
const Byte* Job::unpack(const Byte* buffer)
{
const Byte* cursor = buffer;
cursor = problem_ptr->unpack(cursor);
cursor = read_from_buffer(rank, cursor);
return cursor;
}
static ssize_t buffered_pread(couch_file_handle handle, void *buf, size_t nbyte, off_t offset)
{
#if LOG_BUFFER
//fprintf(stderr, "r");
#endif
buffered_file_handle *h = (buffered_file_handle*)handle;
// Flush the write buffer before trying to read anything:
couchstore_error_t err = flush_buffer(h->write_buffer);
if (err < 0) {
return err;
}
ssize_t total_read = 0;
while (nbyte > 0) {
file_buffer* buffer = find_buffer(h, offset);
// Read as much as we can from the current buffer:
ssize_t nbyte_read = read_from_buffer(buffer, buf, nbyte, offset);
if (nbyte_read == 0) {
/*if (nbyte > buffer->capacity) {
// Remainder won't fit in a single buffer, so just read it directly:
nbyte_read = h->raw_ops->pread(h->raw_ops_handle, buf, nbyte, offset);
if (nbyte_read < 0) {
return nbyte_read;
}
} else*/ {
// Move the buffer to cover the remainder of the data to be read.
off_t block_start = offset - (offset % READ_BUFFER_CAPACITY);
err = load_buffer_from(buffer, block_start, (size_t)(offset + nbyte - block_start));
if (err < 0) {
return err;
}
nbyte_read = read_from_buffer(buffer, buf, nbyte, offset);
if (nbyte_read == 0)
break; // must be at EOF
}
}
buf = (char*)buf + nbyte_read;
nbyte -= nbyte_read;
offset += nbyte_read;
total_read += nbyte_read;
}
return total_read;
}
const Byte* JobResult::unpack(const Byte* buffer)
{
const Byte* cursor = buffer;
cursor = read_from_buffer(nnz, cursor);
cursor = read_from_buffer(n, cursor);
cursor = read_from_buffer(rank, cursor);
cursor = read_from_buffer(assembly_time, cursor);
size_t matrix_byte_size = nnz*sizeof(Real);
matrix_ptr = new Real[nnz];
memcpy(matrix_ptr, cursor, matrix_byte_size);
cursor += matrix_byte_size;
size_t rhs_byte_size = n*sizeof(Real);
rhs_ptr = new Real[n];
memcpy(rhs_ptr, cursor, rhs_byte_size);
cursor += rhs_byte_size;
return cursor;
}
void trace_record_finish(TraceBufferRecord *rec)
{
TraceRecord record;
read_from_buffer(rec->tbuf_idx, &record, sizeof(TraceRecord));
smp_wmb(); /* write barrier before marking as valid */
record.event |= TRACE_RECORD_VALID;
write_to_buffer(rec->tbuf_idx, &record, sizeof(TraceRecord));
if ((trace_idx - writeout_idx) > TRACE_BUF_FLUSH_THRESHOLD) {
flush_trace_file(false);
}
}
const Byte* Solution::unpack(const Byte* buffer)
{
const Byte* cursor = buffer;
cursor = read_from_buffer(n, cursor);
size_t x_byte_size = n*sizeof(Real);
x_ptr = new Real[n];
memcpy(x_ptr, cursor, x_byte_size);
cursor += x_byte_size;
return cursor;
}
// -----------------------------------------------------------------------------
void BLeafNode::init_restore( // load an exist node from disk to init
BTree* btree, // b-tree of this node
int block) // addr of disk for this node
{
btree_ = btree; // init <btree_>
block_ = block; // init <block_>
dirty_ = false; // init <dirty_>
// get block length
int b_length = btree_->file_->get_blocklength();
// -------------------------------------------------------------------------
// Init <capacity_keys> and calc key size
// -------------------------------------------------------------------------
int key_size = get_key_size(b_length);
// init <key>
key_ = new float[capacity_keys_];
for (int i = 0; i < capacity_keys_; i++) {
key_[i] = MINREAL;
}
// calc header size
int header_size = get_header_size();
// calc entry size
int entry_size = get_entry_size();
// init <capacity>
capacity_ = (b_length - header_size - key_size) / entry_size;
if (capacity_ < 100) { // at least 100 entries
printf("capacity = %d\n", capacity_);
error("BLeafNode::init_store capacity too small.\n", true);
}
id_ = new int[capacity_]; // init <id>
for (int i = 0; i < capacity_; i++) {
id_[i] = -1;
}
// -------------------------------------------------------------------------
// Read the buffer <blk> to init <level_>, <num_entries_>, <left_sibling_>,
// <right_sibling_>, <num_keys_> <key_> and <id_>
// -------------------------------------------------------------------------
char* blk = new char[b_length];
btree_->file_->read_block(blk, block);
read_from_buffer(blk);
delete[] blk; blk = NULL;
}
/* CRYPTO_sysrand puts |requested| random bytes into |out|. */
void CRYPTO_sysrand(uint8_t *out, size_t requested) {
if (requested == 0) {
return;
}
CRYPTO_once(&once, init_once);
if (urandom_buffering && requested < BUF_SIZE) {
struct rand_buffer *buf = get_thread_local_buffer();
if (buf != NULL) {
read_from_buffer(buf, out, requested);
return;
}
}
if (!fill_with_entropy(out, requested)) {
abort();
}
}
int direct_io_read(int fd, void* buff, ssize_t size)
{
int read_total = size;
int read_size = 0;
int update_size = 0;
do{
// read buffer first
read_size = read_from_buffer((char*)buff + read_total - size, size);
size -= read_size;
if(size > 0){
// update buffer from file
update_size = update_from_file();
if(0 == update_size){
// to the end of file
break;
}
}
}while(size > 0);
// return read size
//DIO_TRACE("buffer(%d),file(%d),tell(%d)", read_pos, lseek(read_fd, 0, SEEK_CUR), direct_io_tell(fd));
return read_total - size;
}
// -----------------------------------------------------------------------------
void BIndexNode::init_restore( // load an exist node from disk to init
BTree* btree, // b-tree of this node
int block) // addr of disk for this node
{
btree_ = btree; // init <btree_>
block_ = block; // init <block_>
dirty_ = false; // init <dirty_>
// get block length
int b_len = btree_->file_->get_blocklength();
// init <capacity_>
capacity_ = (b_len - get_header_size()) / get_entry_size();
if (capacity_ < 50) { // at least 50 entries
printf("capacity = %d\n", capacity_);
error("BIndexNode::init_restore capacity too small.\n", true);
}
key_ = new float[capacity_]; // init <key_>
for (int i = 0; i < capacity_; i++) {
key_[i] = MINREAL;
}
son_ = new int[capacity_]; // init <son_>
for (int i = 0; i < capacity_; i++) {
son_[i] = -1;
}
// -------------------------------------------------------------------------
// Read the buffer <blk> to init <level_>, <num_entries_>, <left_sibling_>,
// <right_sibling_>, <key_> and <son_>.
// -------------------------------------------------------------------------
char* blk = new char[b_len];
btree_->file_->read_block(blk, block);
read_from_buffer(blk);
delete[] blk; blk = NULL;
}
/* Read from remote client */
static Npfcall* openssl_remote_read(Npfid *afid, u64 offset, u32 count) {
struct openssl_session_auth_context* ctx;
int read_length;
u8* data;
Npfcall* rc;
ctx = (struct openssl_session_auth_context*)afid->aux;
if ( ctx == NULL )
return np_create_rerror("No session context",EINVAL,1);
/* We do not support offsets in our protocol */
if ( offset != 0 )
return np_create_rerror("No offset supported",EINVAL,1);
data = malloc(count);
if ( !data )
return np_create_rerror("No mem",ENOMEM,1);
read_from_buffer(&ctx->output_buffer, count, (char*)data, &read_length);
rc = np_create_rread(read_length, data);
free(data);
return rc;
}
/* Read from server side */
static int openssl_local_read(struct openssl_session_auth_context* ctx, int requested_length, char* result, int* result_length) {
return read_from_buffer(&ctx->input_buffer, requested_length, result, result_length);
}
static ssize_t i_stream_seekable_read(struct istream_private *stream)
{
struct seekable_istream *sstream = (struct seekable_istream *)stream;
const unsigned char *data;
size_t size, pos;
ssize_t ret;
if (sstream->fd == -1) {
if (read_from_buffer(sstream, &ret))
return ret;
/* copy everything to temp file and use it as the stream */
if (copy_to_temp_file(sstream) < 0) {
stream->max_buffer_size = (size_t)-1;
if (!read_from_buffer(sstream, &ret))
i_unreached();
return ret;
}
i_assert(sstream->fd != -1);
}
stream->buffer = CONST_PTR_OFFSET(stream->buffer, stream->skip);
stream->pos -= stream->skip;
stream->skip = 0;
i_assert(stream->istream.v_offset + stream->pos <= sstream->write_peak);
if (stream->istream.v_offset + stream->pos == sstream->write_peak) {
/* need to read more */
if (sstream->cur_input == NULL ||
i_stream_get_data_size(sstream->cur_input) == 0) {
ret = read_more(sstream);
if (ret == -1 || ret == 0)
return ret;
}
/* save to our file */
data = i_stream_get_data(sstream->cur_input, &size);
ret = write(sstream->fd, data, size);
if (ret <= 0) {
if (ret < 0 && !ENOSPACE(errno)) {
i_error("istream-seekable: write_full(%s) failed: %m",
sstream->temp_path);
}
if (i_stream_seekable_write_failed(sstream) < 0)
return -1;
if (!read_from_buffer(sstream, &ret))
i_unreached();
return ret;
}
i_stream_sync(sstream->fd_input);
i_stream_skip(sstream->cur_input, ret);
sstream->write_peak += ret;
}
i_stream_seek(sstream->fd_input, stream->istream.v_offset);
ret = i_stream_read_memarea(sstream->fd_input);
if (ret <= 0) {
stream->istream.eof = sstream->fd_input->eof;
stream->istream.stream_errno =
sstream->fd_input->stream_errno;
} else {
ret = -2;
}
stream->buffer = i_stream_get_data(sstream->fd_input, &pos);
stream->pos -= stream->skip;
stream->skip = 0;
ret = pos > stream->pos ? (ssize_t)(pos - stream->pos) : ret;
stream->pos = pos;
return ret;
}
/* This is the Thread which will read data from the Circular buffer
* and print out to the Console
*/
void* consumer_thread(void *arg)
{
circ_buffer_t *rcv_buf;
double mean, smoothed_mean;
int sockfd;
packet_info_t *pkt_info;
double get_rand;
bool data_present, was_buf_full, done = FALSE;
unsigned int ack_seq;
unsigned short new_win;
double prob_loss;
assert(arg);
assert(rcv_buf = ((thread_arg *)arg)->rcv_buf);
assert(((thread_arg *)arg)->config);
mean = smoothed_mean = ((thread_arg *)arg)->config->mean;
prob_loss = ((thread_arg *)arg)->config->prob_loss;
sockfd = ((thread_arg *)arg)->sockfd;
free(arg);
Pthread_detach(pthread_self());
while (!done) {
get_rand = (double)rand()/RAND_MAX;
smoothed_mean = -1.0 * mean * log(get_rand);
printf("[Consumer Thread] Wake Up in %lf ms\n", smoothed_mean);
usleep((useconds_t)(smoothed_mean * 1000));
data_present = FALSE;
was_buf_full = FALSE;
Pthread_mutex_lock(&buf_mutex);
if (IS_BUFFER_FULL(rcv_buf))
was_buf_full = TRUE;
while(read_from_buffer(rcv_buf, &pkt_info) >= 0)
{
data_present = TRUE;
fprintf(stdout, "[Consumer thread] [seq:%u]\n%.*s\n", pkt_info->seq,
pkt_info->data_len, pkt_info->data);
if(IS_EOF(pkt_info))
{
done = TRUE;
break;
}
free_pkt_info(pkt_info);
pkt_info = NULL;
}
/* Save off these values as we are releasing the lock below */
new_win = window_size(rcv_buf);
ack_seq = NEXT_ACK(rcv_buf);
Pthread_mutex_unlock(&buf_mutex);
if (!data_present)
printf("[Consumer Thread] No data this time around\n");
if(was_buf_full)
{
/* Advertise New Opened Up window */
send_ack(sockfd, new_win, 0, ack_seq, 0, prob_loss);
}
}
exit(0);
}
