int32 conn_alloc(MeshConnectivity *conn, uint32 num, uint32 n_incident)
{
int32 ret = RET_OK;
if ((conn->num > 0) && (conn->n_incident > 0)) {
conn_free(conn);
}
if (num > 0) {
conn->num = num;
conn->offsets = alloc_mem(uint32, num + 1);
ERR_CheckGo(ret);
}
if (n_incident > 0) {
conn->n_incident = n_incident;
conn->indices = alloc_mem(uint32, n_incident);
ERR_CheckGo(ret);
} else if (num == 0) { // Empty connectivity.
conn->n_incident = n_incident;
conn->indices = 0;
}
end_label:
if (ERR_Chk) {
conn_free(conn);
}
return(ret);
}
void
cylinder (double x0, double y0, double z0, double size, double diameter, double alpha,
double betha, int arcs, int circles)
{
int num_points;
double *cylinder_3D_points, *left_points, *right_points;
CYLINDER cylinder;
num_points = arcs*circles;
cylinder_3D_points = (double *) alloc_mem (3 * num_points * sizeof (double));
left_points = (double *) alloc_mem (2 * num_points * sizeof (double));
right_points = (double *) alloc_mem (2 * num_points * sizeof (double));
cylinder.x = x0;
cylinder.y = y0;
cylinder.z = z0;
cylinder.size = size;
cylinder.diameter = diameter;
cylinder.alpha = alpha;
cylinder.betha = betha;
compute_3D_cylinder (&cylinder, cylinder_3D_points, arcs, circles, cylinder.size, 180);
CameraProjectionRight(num_points, left_points, cylinder_3D_points, LEFT_CAMERA);
CameraProjectionRight(num_points, right_points, cylinder_3D_points, RIGHT_CAMERA);
// overwrite_points (num_points, left_points, right_points);
project_cylinder_2D_points_into_disparity_map (num_points, left_points, right_points);
free (right_points);
free (left_points);
free (cylinder_3D_points);
}
Character *new_char()
{
Character *ch = (Character *) alloc_mem(1, sizeof(Character));
ch->flags = new_flag();
ch->affectedBy = new_flag();
ch->next = 0;
ch->next_in_area = 0;
ch->name = str_empty;
ch->position = POS_STANDING;
ch->sex = SEX_NEUTRAL;
ch->description = str_empty;
ch->hit = ch->maxHit = 100;
ch->mana = ch->maxMana = 100;
ch->move = ch->maxMove = 100;
ch->writelnf = writef_line_to_char;
ch->writef = writef_to_char;
ch->writeln = write_line_to_char;
ch->write = write_to_char;
ch->page = page_to_char;
ch->title = title_to_char;
ch->titlef = titlef_to_char;
ch->classes = alloc_mem(1, sizeof(int));
ch->classes[0] = -1;
ch->size = SIZE_AVERAGE;
for (int i = 0; i < MAX_DAM; i++) {
ch->resists[i] = 100;
}
return ch;
}
static item_t* fill_get_response_header(char *key ,intptr_t bytes){
char *s=(char *)alloc_mem(pool,20);
sprintf(s,"%ld",bytes);
intptr_t first_length=strlen(first_get_response);
intptr_t key_length=strlen(key);
intptr_t middle_length=strlen(middle);
intptr_t s_length=strlen(s);
intptr_t command_end_length=strlen(command_end);
intptr_t length=first_length+key_length+middle_length+s_length+command_end_length;
char *c=(char *)alloc_mem(pool,length);
memset(c,0,length);
intptr_t index=0;
memcpy(c,first_get_response,first_length);
index+=first_length;
memcpy(c+index,key,key_length);
index+=key_length;
memcpy(c+index,middle,middle_length);
index+=middle_length;
memcpy(c+index,s,s_length);
index+=s_length;
memcpy(c+index,command_end,command_end_length);
index+=command_end_length;
free_mem(s);
item_t *i=init_item();
i->data=c;
i->c_size=length;
return i;
}
// intiailize (alloc mem, check/set firstrun bytes)
u8 init_flash() {
#if 1
#else
u32 i;
print_dbg("\r\n init flash... ");
// allocate bfin loader buf
////////////////////
/////////// TESTING
#if 0
bfinLdrData = alloc_mem(BFIN_LDR_MAX_BYTES);
#else
bfinLdrData = alloc_mem(BFIN_LDR_MAX_BYTES * 4);
#endif
for(i=0; i<BFIN_LDR_MAX_BYTES; i++) { bfinLdrData[i] = 0; }
if(flash_nvram_data.firstRun != FIRSTRUN_MAGIC) {
// set size=0 so we won't attempt unitialized bfin load on next start
bfinLdrSize = 0;
flashc_memset32((void*)&(flash_nvram_data.ldrSize), 0x00000000, 4, true);
// do this only after succesful app launch
// flashc_memset32((void*)&(flash_nvram_data.firstRun), FIRSTRUN_MAGIC, 4, true);
return 1;
} else {
// firstrun already happened
return 0;
}
#endif
}
void alloc_key_buff( void )
{
INT_TYPE i;
int num_procs;
#ifdef _OPENMP
num_procs = omp_get_max_threads();
#else
num_procs = 1;
#endif
#ifdef USE_BUCKETS
bucket_size = (INT_TYPE **)alloc_mem(sizeof(INT_TYPE *) * num_procs);
for (i = 0; i < num_procs; i++) {
bucket_size[i] = (INT_TYPE *)alloc_mem(sizeof(INT_TYPE) * NUM_BUCKETS);
}
#pragma omp parallel for
for( i=0; i<NUM_KEYS; i++ )
key_buff2[i] = 0;
#else /*USE_BUCKETS*/
key_buff1_aptr = (INT_TYPE **)alloc_mem(sizeof(INT_TYPE *) * num_procs);
key_buff1_aptr[0] = key_buff1;
for (i = 1; i < num_procs; i++) {
key_buff1_aptr[i] = (INT_TYPE *)alloc_mem(sizeof(INT_TYPE) * MAX_KEY);
}
#endif /*USE_BUCKETS*/
}
void test_alloc(int testcase, int lite)
{
if (lite)
alloc_mem(TESTMEM + MB, testcase);
else
while(1)
if (alloc_mem(LENGTH, testcase))
return;
}
/*
* Page to one char, new colour version, by Lope.
*/
void page_to_char( const char *txt, CHAR_DATA *ch )
{
const char *point;
char *point2;
char buf[ MAX_STRING_LENGTH * 4 ];
int skip = 0;
#if defined(macintosh)
send_to_char( txt, ch );
#else
buf[0] = '\0';
point2 = buf;
if( txt && ch->desc )
{
if( IS_SET( ch->act, PLR_COLOUR ) )
{
for( point = txt ; *point ; point++ )
{
if( *point == '{' )
{
point++;
skip = colour( *point, ch, point2 );
while( skip-- > 0 )
++point2;
continue;
}
*point2 = *point;
*++point2 = '\0';
}
*point2 = '\0';
ch->desc->showstr_head = alloc_mem( strlen( buf ) + 1 );
strcpy( ch->desc->showstr_head, buf );
ch->desc->showstr_point = ch->desc->showstr_head;
show_string( ch->desc, "" );
}
else
{
for( point = txt ; *point ; point++ )
{
if( *point == '{' )
{
point++;
continue;
}
*point2 = *point;
*++point2 = '\0';
}
*point2 = '\0';
ch->desc->showstr_head = alloc_mem( strlen_color( buf ) + 1 );
strcpy( ch->desc->showstr_head, buf );
ch->desc->showstr_point = ch->desc->showstr_head;
show_string( ch->desc, "" );
}
}
#endif
return;
}
static void write_null(connection_t *conn,char *key){
intptr_t length=strlen(data_end);
char *s=(char *)alloc_mem(pool,length);
memcpy(s,data_end,length);
item_t *i=(item_t *)alloc_mem(pool,length);
i->data=s;
i->c_size=length;
push(conn->wc->w_queue,i);
}
static status_t
cx23882_buffers_alloc(cx23882_device *device)
{
device->dma_buf1_area = alloc_mem(&device->dma_buf1_virt, &device->dma_buf1_phys, DMA_BUFFER_SIZE, B_READ_AREA, "cx23882 dma buf 1");
device->dma_buf2_area = alloc_mem(&device->dma_buf2_virt, &device->dma_buf2_phys, DMA_BUFFER_SIZE, B_READ_AREA, "cx23882 dma buf 2");
if (device->dma_buf1_area < B_OK || device->dma_buf2_area < B_OK) {
cx23882_buffers_free(device);
return B_NO_MEMORY;
}
return B_OK;
}
LMS::LMS ( //constructor
inT32 size //samplesize
):samplesize (size) {
samplecount = 0;
a = 0;
m = 0.0f;
c = 0.0f;
samples = (FCOORD *) alloc_mem (size * sizeof (FCOORD));
errors = (float *) alloc_mem (size * sizeof (float));
line_error = 0.0f;
fitted = FALSE;
}
QSPLINE & QSPLINE::operator= ( //assignment
const QSPLINE & source) {
if (xcoords != NULL)
free_mem(xcoords);
if (quadratics != NULL)
free_mem(quadratics);
segments = source.segments;
xcoords = (inT32 *) alloc_mem ((segments + 1) * sizeof (inT32));
quadratics = (QUAD_COEFFS *) alloc_mem (segments * sizeof (QUAD_COEFFS));
memmove (xcoords, source.xcoords, (segments + 1) * sizeof (inT32));
memmove (quadratics, source.quadratics, segments * sizeof (QUAD_COEFFS));
return *this;
}
static intptr_t process_set_body(connection_t *conn){
//check一下当前buffer数据的剩余多少
buffer_t *b=conn->rbuf;
intptr_t count=b->limit-b->current;
if(count==0){
return AGAIN;
}
//开始存储set数据
read_context_t *rc=conn->rc;
char *key=rc->key->data;
queue_t *q=(queue_t *)get(key,hash);
if(q==NULL){
//初始化队列，加入hash中
q=init_queue();
char *q_name=(char *)alloc_mem(pool,strlen(key));
strcpy(q_name,key);
put(q_name,q,hash);
//开始统计这个队列
start_queue_stat(q_name);
}
intptr_t fill=0;
intptr_t result=AGAIN;
item_t *i=init_item();
i->size=rc->last_bytes-2;
//如果当前buffer的数据包含了所有的set数据包括最后的/r/n
if(count>=rc->last_bytes){
fill=rc->last_bytes;
i->end=1;
result=OK;
write_set_response(conn);
//加入队列数据统计
increase_queue_stat(key,i->size);
}else{
//如果buffer不够了那么先把这部分数据copy出来，放入一个item中
fill=count;
rc->last_bytes-=fill;
}
char *c=(char *)alloc_mem(pool,fill);
memset(c,0,fill);
memcpy(c,b->data+b->current,fill);
i->data=c;
i->c_size=fill;
push(q,i);
add_set_sync_data(key,i);
b->current+=fill;
return result;
}
void QSPLINE::extrapolate( //linear extrapolation
double gradient, //gradient to use
int xmin, //new left edge
int xmax //new right edge
) {
register int segment; /*current segment of spline */
int dest_segment; //dest index
int *xstarts; //new boundaries
QUAD_COEFFS *quads; //new ones
int increment; //in size
increment = xmin < xcoords[0] ? 1 : 0;
if (xmax > xcoords[segments])
increment++;
if (increment == 0)
return;
xstarts = (int *) alloc_mem ((segments + 1 + increment) * sizeof (int));
quads =
(QUAD_COEFFS *) alloc_mem ((segments + increment) * sizeof (QUAD_COEFFS));
if (xmin < xcoords[0]) {
xstarts[0] = xmin;
quads[0].a = 0;
quads[0].b = gradient;
quads[0].c = y (xcoords[0]) - quads[0].b * xcoords[0];
dest_segment = 1;
}
else
dest_segment = 0;
for (segment = 0; segment < segments; segment++) {
xstarts[dest_segment] = xcoords[segment];
quads[dest_segment] = quadratics[segment];
dest_segment++;
}
xstarts[dest_segment] = xcoords[segment];
if (xmax > xcoords[segments]) {
quads[dest_segment].a = 0;
quads[dest_segment].b = gradient;
quads[dest_segment].c = y (xcoords[segments])
- quads[dest_segment].b * xcoords[segments];
dest_segment++;
xstarts[dest_segment] = xmax + 1;
}
segments = dest_segment;
free_mem(xcoords);
free_mem(quadratics);
xcoords = (inT32 *) xstarts;
quadratics = quads;
}
/*************************************************************************
* PIXROW::PIXROW()
*
* Constructor for a specified size PIXROW from a blob
*************************************************************************/
PIXROW::PIXROW(INT16 pos, INT16 count, PBLOB *blob) {
OUTLINE_LIST *outline_list;
OUTLINE_IT outline_it;
POLYPT_LIST *pts_list;
POLYPT_IT pts_it;
INT16 i;
FCOORD pt;
FCOORD vec;
float y_coord;
INT16 x_coord;
row_offset = pos;
row_count = count;
min = (INT16 *) alloc_mem (count * sizeof (INT16));
max = (INT16 *) alloc_mem (count * sizeof (INT16));
outline_list = blob->out_list ();
outline_it.set_to_list (outline_list);
for (i = 0; i < count; i++) {
min[i] = MAX_INT16 - 1;
max[i] = -MAX_INT16 + 1;
y_coord = row_offset + i + 0.5;
for (outline_it.mark_cycle_pt ();
!outline_it.cycled_list (); outline_it.forward ()) {
pts_list = outline_it.data ()->polypts ();
pts_it.set_to_list (pts_list);
for (pts_it.mark_cycle_pt ();
!pts_it.cycled_list (); pts_it.forward ()) {
pt = pts_it.data ()->pos;
vec = pts_it.data ()->vec;
if ((vec.y () != 0) &&
(((pt.y () <= y_coord) && (pt.y () + vec.y () >= y_coord))
|| ((pt.y () >= y_coord)
&& (pt.y () + vec.y () <= y_coord)))) {
/* The segment crosses y_coord so find x-point and check for min/max. */
x_coord = (INT16) floor ((y_coord -
pt.y ()) * vec.x () / vec.y () +
pt.x () + 0.5);
if (x_coord < min[i])
min[i] = x_coord;
x_coord--; //to get pix to left of line
if (x_coord > max[i])
max[i] = x_coord;
}
}
}
}
}
////复制父进程的地址空间
static int copy_mem(int pid,struct task_struct *p)
{
struct descriptor *dp = &proc_table[pid].ldts[INDEX_LDT_C];
int text_base = get_base(dp);
int text_limit = get_limit(dp);
int text_size = (text_limit + 1) * ((dp->limit_high_attr2 * 0x80)?4096:1);
dp = &proc_table[pid].ldts[INDEX_LDT_D];
int data_base = get_base(dp);
int data_limit= get_limit(dp);
int data_size = (text_limit + 1) * ((dp->limit_high_attr2 * 0x80)?4096:1);
assert((text_base == data_base) &&
(text_limit == data_limit) &&
(text_size == data_size)
);
int child_base = alloc_mem(p->pid,text_size);
// printk("child_base = %d\t text_base = %d\t text_size = %d\n",child_base,text_base,text_size);
// memcpy((void *)child_base,(void *)(text_base),text_size);
// printk("child_base = %d\t text_base = %d\t text_size = %d\n",child_base,text_base,text_size);
phys_copy((char *)child_base,(char *)(text_base),text_size);
return child_base;
}
int _brk(void *addr)
{
vir_bytes target = roundup((vir_bytes)addr, VM_PAGE_SIZE), v;
extern char _end;
extern char *_brksize;
static vir_bytes prevbrk = (vir_bytes) &_end;
struct vmproc *vmprocess = &vmproc[VM_PROC_NR];
for(v = roundup(prevbrk, VM_PAGE_SIZE); v < target;
v += VM_PAGE_SIZE) {
phys_bytes mem, newpage = alloc_mem(1, 0);
if(newpage == NO_MEM) return -1;
mem = CLICK2ABS(newpage);
if(pt_writemap(vmprocess, &vmprocess->vm_pt,
v, mem, VM_PAGE_SIZE,
ARCH_VM_PTE_PRESENT
| ARCH_VM_PTE_USER
| ARCH_VM_PTE_RW
#if defined(__arm__)
| ARM_VM_PTE_WB
#endif
, 0) != OK) {
free_mem(newpage, 1);
return -1;
}
prevbrk = v + VM_PAGE_SIZE;
}
_brksize = (char *) addr;
if(sys_vmctl(SELF, VMCTL_FLUSHTLB, 0) != OK)
panic("flushtlb failed");
return 0;
}
// initialize network at pre-allocated memory
void net_init(void) {
u32 i;
net = (ctlnet_t*)alloc_mem(sizeof(ctlnet_t));
for(i=0; i<NET_OP_POOL_SIZE; i++) {
net->opPoolMem[i] = 0x00;
}
net->opPool = (void*)&(net->opPoolMem);
net->opPoolOffset = 0;
net->numOps = 0;
net->numIns = 0;
net->numOuts = 0;
net->numParams = 0;
// unassign all I/O nodes
for(i=0; i<NET_INS_MAX; i++) {
net_init_inode(i);
}
for(i=0; i<NET_OUTS_MAX; i++) {
net_init_onode(i);
}
print_dbg("\r\n initialized ctlnet, byte count: ");
print_dbg_hex(sizeof(ctlnet_t));
add_sys_ops();
// ???
netActive = 1;
}
void c_rt_lib0init_advanced(int catch_signals, char * (*die_f)(), char * (*logs_f)()) {
_global_const_offset_ = sizeof(NlInt);
if (sizeof(NlFloat) > _global_const_offset_)
_global_const_offset_ = sizeof(NlFloat);
if (sizeof(NlString) > _global_const_offset_)
_global_const_offset_ = sizeof(NlString);
_false = c_rt_lib0ov_mk_none(c_rt_lib0string_new("FALSE"));
_true = c_rt_lib0ov_mk_none(c_rt_lib0string_new("TRUE"));
_array = c_rt_lib0array_new_alloc();
_hash = c_rt_lib0hash_new_alloc();
_int_0 = c_rt_lib0int_new(-1);
((NlInt *)_int_0)->i = 0;
_int_1 = c_rt_lib0int_new(-1);
((NlInt *)_int_1)->i = 1;
char *t = (char*)alloc_mem(sizeof(char));
t[0] = '\0';
_empty_str = c_rt_lib0string_new_alloc(t,0,1);
___global_const_init();
if (catch_signals) {
c_rt_lib_priv_register_signal_handler(SIGSEGV);
}
die_additional_info = die_f;
logs_dir_f = logs_f;
}
C_OUTLINE::C_OUTLINE (
//constructor
CRACKEDGE * startpt, //outline to convert
ICOORD bot_left, //bounding box
ICOORD top_right, inT16 length //length of loop
):box (bot_left, top_right), start (startpt->pos), offsets(NULL) {
inT16 stepindex; //index to step
CRACKEDGE *edgept; //current point
stepcount = length; //no of steps
if (length == 0) {
steps = NULL;
return;
}
//get memory
steps = (uinT8 *) alloc_mem (step_mem());
memset(steps, 0, step_mem());
edgept = startpt;
for (stepindex = 0; stepindex < length; stepindex++) {
//set compact step
set_step (stepindex, edgept->stepdir);
edgept = edgept->next;
}
}
/* Inutilizzata */
BUFFER *new_buf_size(int size)
{
BUFFER *buffer;
if (buf_free == NULL)
buffer = alloc_perm(sizeof(*buffer));
else
{
buffer = buf_free;
buf_free = buf_free->next;
}
buffer->next = NULL;
buffer->state = BUFFER_SAFE;
buffer->size = get_size(size);
if (buffer->size == -1)
{
bug("new_buf: buffer size %d too large.",size);
exit(1);
}
buffer->string = alloc_mem(buffer->size);
buffer->string[0] = '\0';
VALIDATE(buffer);
return buffer;
}
void make_input_image_class_cnae (INPUT_DESC *input, int w, int h)
{
char message[256];
input->tfw = nearest_power_of_2 (w);
input->tfh = nearest_power_of_2 (h);
input->ww = w;
input->wh = h;
switch(TYPE_SHOW)
{
case SHOW_FRAME:
input->vpw = input->neuron_layer->dimentions.x;
input->vph = input->neuron_layer->dimentions.y;
break;
case SHOW_WINDOW:
input->vph = h;
input->vpw = w;
break;
default:
sprintf(message,"%d. It can be SHOW_FRAME or SHOW_WINDOW.",TYPE_SHOW);
Erro ("Invalid Type Show ", message, " Error in update_input_image.");
return;
}
input->vpxo = 0;
input->vpyo = h - input->vph;
if(input->image == NULL)
input->image = (GLubyte *) alloc_mem (input->tfw * input->tfh * 3 * sizeof (GLubyte));
}
void SimpleGrayImage::resize(int wid, int hig)
{
assert ((wid > 0) && (hig > 0));
w = wid;
h = hig;
alloc_mem(wid, hig);
}
int SwitchPortCPU::outputPacket(PriPacket& pkg) {
if( pkg.getSourcePort() == CPU_Port_Sn ) {
return -1;
}
uint16 RxLen = 0;
uint8* RxData = pkg.getStdStream(&RxLen);
if( RxLen < 30 || RxData == 0 ) {
std::cout << "SwitchPortCPU send error: len " << (int)RxLen << std::endl;
return -1;
}
#ifdef EZ_DEBUG
trace->sendOnePkg();
#endif
tsk_lock();
OS_FRAME* frame = alloc_mem (RxLen | 0x80000000);
tsk_unlock();
if (frame != NULL) {
memcpy( &frame->data[0], RxData, RxLen);
put_in_queue(frame);
os_evt_set(0x0001, t_tcpTask);
return 1;
}
else {
std::cout << "SwitchPortCPU::outputPacket() alloc_mem(" << (int)RxLen << ") error" << std::endl;
}
return -1;
}
bool add_buf(BUFFER *buffer, char *string) {
int len;
char *oldstr;
int oldsize;
oldstr = buffer->string;
oldsize = buffer->size;
if (buffer->state == BUFFER_OVERFLOW)
return FALSE;
len = strlen(buffer->string) + strlen(string) + 1;
while (len >= buffer->size) {
buffer->size = get_size(buffer->size + 1);
{
if (buffer->size == -1) {
buffer->size = oldsize;
buffer->state = BUFFER_OVERFLOW;
bug("Add_buf: buffer overflow past size %d", buffer->size);
return FALSE;
}
}
}
if (buffer->size != oldsize) {
buffer->string = alloc_mem(buffer->size);
strcpy(buffer->string, oldstr);
free_mem(oldstr, oldsize);
}
strcat(buffer->string, string);
return TRUE;
}
DESCRIPTOR_DATA *new_descriptor(void)
{
static DESCRIPTOR_DATA d_zero;
DESCRIPTOR_DATA *d;
if (descriptor_free == NULL)
d = alloc_perm(sizeof(*d));
else
{
d = descriptor_free;
descriptor_free = descriptor_free->next;
}
*d = d_zero;
VALIDATE(d);
d->connected = CON_GET_NAME;
d->showstr_head = NULL;
d->showstr_point = NULL;
d->outsize = 2000;
d->outtop = 0;
d->pEdit = NULL; /* OLC */
d->pString = NULL; /* OLC */
d->editor = 0; /* OLC */
d->outbuf = alloc_mem( d->outsize );
return d;
}
static void child_alloc(int testcase, int lite, int threads)
{
int i;
pthread_t *th;
if (lite) {
int ret = alloc_mem(TESTMEM + MB, testcase);
exit(ret);
}
th = malloc(sizeof(pthread_t) * threads);
if (!th) {
tst_resm(TINFO | TERRNO, "malloc");
goto out;
}
for (i = 0; i < threads; i++) {
TEST(pthread_create(&th[i], NULL, child_alloc_thread,
(void *)((long)testcase)));
if (TEST_RETURN) {
tst_resm(TINFO | TRERRNO, "pthread_create");
goto out;
}
}
/* wait for one of threads to exit whole process */
while (1)
sleep(1);
out:
exit(1);
}
static int
reservedqueue_addslot(struct reserved_pages *rq)
{
phys_bytes cl, cl_addr;
void *vir;
struct reserved_pageslot *rps;
sanitycheck_rq(rq);
if((cl = alloc_mem(rq->npages, rq->allocflags)) == NO_MEM)
return ENOMEM;
cl_addr = CLICK2ABS(cl);
vir = NULL;
if(rq->mappedin) {
if(!(vir = vm_mappages(cl_addr, rq->npages))) {
free_mem(cl, rq->npages);
printf("reservedqueue_addslot: vm_mappages failed\n");
return ENOMEM;
}
}
rps = &rq->slots[rq->n_available];
reservedqueue_fillslot(rq, rps, cl_addr, vir);
return OK;
}
int _runprocess(resources computer_resources, node_t *queue) {
pid_t pid = 0;
int keep_process = 0;
process handler = queue->proc;
printf("%d\n",handler.Mbytes);
while(queue != NULL) {
if (keep_process == 0) {
handler = pop(&queue);
keep_process = 0;
}
if (alloc_mem(computer_resources, handler.Mbytes) != -1) {
pid = fork();
if (pid == -1) {
return -1;
} else if (pid == 0) {
execlp("./process", NULL);
exit(0);
} else {
sleep(handler.processor_time);
kill(pid, SIGTSTP);
waitpid(pid, 0, 0);
}
} else {
sleep(1);
keep_process = 1;
}
}
return EXIT_SUCCESS;
}
static int
add_page( struct cache *c ) {
int new_page_index;
char **new_pages;
char *new_page;
new_pages = realloc_mem( c->pages, sizeof( char * ) * ( c->page_count + 1 ) );
if( !new_pages ) {
return -1;
}
new_page = alloc_mem( c->page_size );
if( !new_page ) {
return -1;
}
new_page_index = c->page_count;
c->page_count++;
c->pages = new_pages;
c->pages[new_page_index] = new_page;
init_page( c, new_page_index );
return new_page_index;
}
