예제 #1
0
void topological_sort(int **graph, int *indegree, int nodes)
{
    int i, j, cnode;
    int *ts;

    ts = malloc(nodes * sizeof(int));

    for (i = 0; i < nodes; i++) {
        if (indegree[i] == 0) {
            insert_queue(i);
            indegree[i] = -1;
        }
    }
    j = 0;
    while ((cnode = remove_queue()) != -1) {
        for (i = 0; i < nodes; i++) {
            indegree[i] -= graph[cnode][i];
            if (indegree[i] == 0) {
                insert_queue(i);
                indegree[i] = -1;
            }
        }
        ts[j++] = cnode;
        printf("%d\n", cnode);
    }
}
예제 #2
0
void BFS(int v)
{
	int i;
	
	insert_queue(v);
	state[v] = waiting;
	
	while(!isEmpty_queue())
	{
		v = delete_queue();
		printf("Vertex %d visited\n",v);
		state[v] = visited;
		for(i=0; i<n; i++)
		{
			/* Check for adjacent unvisited vertices */
			if(adj[v][i] == 1 && state[i] == initial) 
			{
				insert_queue(i);
				state[i] = waiting;
				printf("-----Tree edge - (%d,%d)\n", v, i);
			}
		}
	}
	printf("\n");
}/*End of BFS()*/
예제 #3
0
static void retry_erase(erase_busy_t *busy, u_int cause)
{
    eraseq_entry_t *erase = busy->erase;
    mtd_request_t req;
    client_t *mtd;
    socket_info_t *s;
    int ret;

    DEBUG(2, "cs: trying erase request 0x%p...\n", busy);
    if (busy->next)
	remove_queue(busy);
    req.Function = MTD_REQ_ERASE | cause;
    req.TransferLength = erase->Size;
    req.DestCardOffset = erase->Offset + erase->Handle->info.CardOffset;
    req.MediaID = erase->Handle->MediaID;
    mtd = erase->Handle->mtd;
    s = SOCKET(mtd);
    mtd->event_callback_args.mtdrequest = &req;
    wacquire(&mtd->mtd_req);
    ret = EVENT(mtd, CS_EVENT_MTD_REQUEST, CS_EVENT_PRI_LOW);
    wrelease(&mtd->mtd_req);
    if (ret == CS_BUSY) {
	DEBUG(2, "  Status = %d, requeueing.\n", req.Status);
	switch (req.Status) {
	case MTD_WAITREQ:
	case MTD_WAITPOWER:
	    insert_queue(&mtd->erase_busy, busy);
	    break;
	case MTD_WAITTIMER:
	case MTD_WAITRDY:
	    if (req.Status == MTD_WAITRDY)
		insert_queue(&s->erase_busy, busy);
	    mod_timer(&busy->timeout, jiffies + req.Timeout*HZ/1000);
	    break;
	}
    } else {
	/* update erase queue status */
	DEBUG(2, "  Ret = %d\n", ret);
	switch (ret) {
	case CS_SUCCESS:
	    erase->State = ERASE_PASSED; break;
	case CS_WRITE_PROTECTED:
	    erase->State = ERASE_MEDIA_WRPROT; break;
	case CS_BAD_OFFSET:
	    erase->State = ERASE_BAD_OFFSET; break;
	case CS_BAD_SIZE:
	    erase->State = ERASE_BAD_SIZE; break;
	case CS_NO_CARD:
	    erase->State = ERASE_BAD_SOCKET; break;
	default:
	    erase->State = ERASE_FAILED; break;
	}
	busy->client->event_callback_args.info = erase;
	EVENT(busy->client, CS_EVENT_ERASE_COMPLETE, CS_EVENT_PRI_LOW);
	kfree(busy);
	/* Resubmit anything waiting for a request to finish */
	wakeup(&mtd->mtd_req);
	retry_erase_list(&mtd->erase_busy, 0);
    }
} /* retry_erase */
예제 #4
0
int main(int argc, char** argv)
{
  Car car;
  Queue check_car;
  int i;

  init_queue(&check_car);

  for(i=0;i<7;i++)
   {
     printf("Enter a car:\n");
     printf("%17s", "mark: ");
     scanf("%s", car.mark);
     printf("%17s"," number: ");
     scanf("%s", car.number);
     //snprintf(car.number,9,"%d",i+1);
     printf("%17s", "production year: ");
     scanf("%hu", &car.year);

     if(insert_queue(&check_car, car) == QUEUE_FULL)
       {
           fprintf(stderr, "Queue overflow\n");
           exit(1);
       }
     printf("\n");
    }
   printf("\n");

  while(remove_queue(&check_car, &car) != QUEUE_EMPTY)
  printf("%10s %7s %4hu\n", car.mark, car.number, car.year);

    queue_free(&check_car);

  return 0;
}
예제 #5
0
int insert_into_queue_recycler(

  pbs_queue *pq)

  {
  int              rc;

  pthread_mutex_lock(q_recycler.mutex);

  memset(pq->qu_qs.qu_name, 0, sizeof(pq->qu_qs.qu_name));
  sprintf(pq->qu_qs.qu_name,"%d",q_recycler.next_id);
  pq->q_being_recycled = TRUE;

  q_recycler.queues.lock();
  if (q_recycler.queues.count() >= MAX_RECYCLE_QUEUES)
    {
    enqueue_threadpool_request(remove_some_recycle_queues, NULL, task_pool);
    }
  q_recycler.queues.unlock();

  rc = insert_queue(&q_recycler.queues,pq);

  update_queue_recycler_next_id();

  pthread_mutex_unlock(q_recycler.mutex);

  return(rc);
  } /* END insert_into_queue_recycler() */
예제 #6
0
int netaware_delay_meta_fwrite()
{
	meta = malloc(sizeof(struct meta_struct));
	meta->offset = handle->offset;
	meta->length = handle->length;
	insert_queue(handle->meta_queue, meta);
	return 0;
}
예제 #7
0
파일: queue_func.c 프로젝트: dhill12/test
pbs_queue *que_alloc(

  char *name,
  int   sv_qs_mutex_held)

  {
  static char *mem_err = "no memory";

  int        i;
  pbs_queue *pq;

  pq = (pbs_queue *)calloc(1, sizeof(pbs_queue));

  if (pq == NULL)
    {
    log_err(errno, __func__, mem_err);

    return(NULL);
    }

  pq->qu_qs.qu_type = QTYPE_Unset;

  pq->qu_mutex = calloc(1, sizeof(pthread_mutex_t));
  pq->qu_jobs = calloc(1, sizeof(struct all_jobs));
  pq->qu_jobs_array_sum = calloc(1, sizeof(struct all_jobs));
  
  if ((pq->qu_mutex == NULL) ||
      (pq->qu_jobs == NULL) ||
      (pq->qu_jobs_array_sum == NULL))
    {
    log_err(ENOMEM, __func__, mem_err);
    return(NULL);
    }

  initialize_all_jobs_array(pq->qu_jobs);
  initialize_all_jobs_array(pq->qu_jobs_array_sum);
  pthread_mutex_init(pq->qu_mutex,NULL);
  lock_queue(pq, "que_alloc", NULL, LOGLEVEL);

  strncpy(pq->qu_qs.qu_name, name, PBS_MAXQUEUENAME);

  insert_queue(&svr_queues,pq);
 
  if (sv_qs_mutex_held == FALSE)
    lock_sv_qs_mutex(server.sv_qs_mutex, __func__);
  server.sv_qs.sv_numque++;
  if (sv_qs_mutex_held == FALSE)
    unlock_sv_qs_mutex(server.sv_qs_mutex, __func__);

  /* set the working attributes to "unspecified" */

  for (i = 0; i < QA_ATR_LAST; i++)
    {
    clear_attr(&pq->qu_attr[i], &que_attr_def[i]);
    }

  return(pq);
  }  /* END que_alloc() */
void bfs(int index,int *dist,struct vertex vert[SIZE])
{
 struct q *queue=NULL;
 struct edge *link;
 vert[index].visit=T;
 queue=insert_queue(index,queue);
 while(queue)
 {
  queue=delet_queue(&index,queue);
  for(link=vert[index].edge_ptr;link;link=link->next)
   if(vert[link->terminal].visit==F)
   {
    vert[link->terminal].visit=T;
    vert[link->terminal].path_lenth=vert[index].path_lenth+1;
    queue=insert_queue(link->terminal,queue);
   }
  }
}
예제 #9
0
main()
{
    int i, j = 0, k;
    int topsort[ MAX ], indeg[ MAX ];

    create_graph();
    printf( "The adjacency matrix is :\n" );
    display();
    /*Find the indegree of each node*/

    for ( i = 1;i <= n;i++ )
        {
            indeg[ i ] = indegree( i );

            if ( indeg[ i ] == 0 )
                insert_queue( i );
        }

    while ( front <= rear )  /*Loop till queue is not empty */
        {
            k = delete_queue();
            topsort[ j++ ] = k; /*Add node k to topsort array*/
            /*Delete all edges going fron node k */

            for ( i = 1;i <= n;i++ )
                {
                    if ( adj[ k ][ i ] == 1 )
                        {
                            adj[ k ][ i ] = 0;
                            indeg[ i ] = indeg[ i ] – 1;

                            if ( indeg[ i ] == 0 )
                                insert_queue( i );
                        }
                } /*End of for*/
        } /*End of while*/

    printf( "Nodes after topological sorting are :\n" );

    for ( i = 0;i < j;i++ )
        printf( "%d ", topsort[ i ] );

    printf( "\n" );
} /*End of main()*/
예제 #10
0
main()
{
	int i,v,count,topo_order[MAX],indeg[MAX];
	
	create_graph();
	
	/*Find the indegree of each vertex*/
	for(i=0;i<n;i++)
	{
		indeg[i] = indegree(i);
		if( indeg[i] == 0 )
			insert_queue(i);
	}
	
	count = 0;

	while(  !isEmpty_queue( ) && count < n )
	{
		v = delete_queue();
    	topo_order[++count] = v; /*Add vertex v to topo_order array*/
		/*Delete all edges going fron vertex v */
		for(i=0; i<n; i++)
		{
			if(adj[v][i] == 1)
			{
				adj[v][i] = 0;
				indeg[i] = indeg[i]-1;
				if(indeg[i] == 0)
					insert_queue(i);
			}
		}
	}
	
	if( count < n )
	{
		printf("No topological ordering possible, graph contains cycle\n");
		exit(1);
	}
	printf("Vertices in topological order are :\n");
	for(i=1; i<=count; i++)
		printf( "%d ",topo_order[i] );
	printf("\n");
}/*End of main()*/
int
snd_seq_oss_write(seq_oss_devinfo_t *dp, const char __user *buf, int count, struct file *opt)
{
	int rc, c, p, ev_size;
	evrec_t rec;

	if (! is_write_mode(dp->file_mode) || dp->writeq == NULL)
		return -EIO;

	c = count;
	p = 0;
	while (c >= SHORT_EVENT_SIZE) {
		if (copy_from_user(rec.c, buf + p, SHORT_EVENT_SIZE))
			break;
		p += SHORT_EVENT_SIZE;

		if (rec.s.code == SEQ_FULLSIZE) {
			/* load patch */
			int fmt = (*(unsigned short *)rec.c) & 0xffff;
			return snd_seq_oss_synth_load_patch(dp, rec.s.dev, fmt, buf, p, c);

		}
		if (ev_is_long(&rec)) {
			/* extended code */
			if (rec.s.code == SEQ_EXTENDED &&
			    dp->seq_mode == SNDRV_SEQ_OSS_MODE_MUSIC)
				return -EINVAL;
			ev_size = LONG_EVENT_SIZE;
			if (c < ev_size)
				break;
			/* copy the reset 4 bytes */
			if (copy_from_user(rec.c + SHORT_EVENT_SIZE, buf + p,
					   LONG_EVENT_SIZE - SHORT_EVENT_SIZE))
				break;
			p += LONG_EVENT_SIZE - SHORT_EVENT_SIZE;

		} else {
			/* old-type code */
			if (dp->seq_mode == SNDRV_SEQ_OSS_MODE_MUSIC)
				return -EINVAL;
			ev_size = SHORT_EVENT_SIZE;
		}

		/* insert queue */
		if ((rc = insert_queue(dp, &rec, opt)) < 0)
			break;

		c -= ev_size;
	}

	if (count == c && is_nonblock_mode(dp->file_mode))
		return -EAGAIN;
	return count - c;
}
예제 #12
0
void ir_default_stmt(nodeType* n)
{
	nodeType* stmt = get_operand(n,0);
	char mylabel[16];
	memset(mylabel,0,16);
	strcat(mylabel,newlabel());
	debugger("%s: ",mylabel);
	fprintf(output,"%s: ",mylabel);
	generate(stmt);
	nodeType* const_exp = empty(EMPTY);
	insert_queue(const_exp,mylabel);
}	
예제 #13
0
void BFS(int v)
{
		int i;
		insert_queue(v);
		state[v]=waiting;
		while(!isempty_queue())
		{
				v=delete_queue();
				printf("%d  ",v);
				state[v]=visited;
				for(i=0;i<n;i++)
				{
						if(adj[v][i]==1&&state[i]==initial)
						{	
								insert_queue(i);
								state[i]=waiting;
						}
				}
		}
		printf("\n");
}
예제 #14
0
파일: test_file.c 프로젝트: nejmd/JPEG
int main()
{
        struct priority_queue *queue = create_queue(10);

        if (queue == NULL)
                printf("create_queue error\n");

        insert_queue(queue, 10, (struct huff_table*)10);
        insert_queue(queue, 11, (struct huff_table*)11);
        insert_queue(queue, 8, (struct huff_table*)8);
        insert_queue(queue, 3, (struct huff_table*)3);
        insert_queue(queue, 7, (struct huff_table*)7);
        insert_queue(queue, 15, (struct huff_table*)15);

        uint32_t priority = 0;
        struct huff_table *table = NULL;

        while (best_queue(queue, &priority, &table)) {

                printf("Table = %ld\n", (uint64_t)table);
                delete_queue(queue);
        }

        free_queue(queue);


        return EXIT_SUCCESS;
}
예제 #15
0
void
email_asciifile_tail( FILE* output, const char* file, int lines )
{
	FILE	*input;
	int		ch, last_ch;
	long	loc;
	int		first_line = TRUE;
	TAIL_QUEUE	queue, *q = &queue;

	if( !file ) {
		return;
	}		

	if( (input=safe_fopen_wrapper_follow(file,"r",0644)) == NULL ) {
	    // try the .old file in the off shoot case we hit this during the transition.
	    std::string szTmp = file;
	    szTmp += ".old"; 
	    
	    if( (input=safe_fopen_wrapper_follow(szTmp.c_str(),"r",0644)) == NULL ) {
		dprintf( D_FULLDEBUG, "Failed to email %s: cannot open file\n", file );
		return;
	    }
	}

	init_queue( q, lines );
	last_ch = '\n';

	while( (ch=getc(input)) != EOF ) {
		if( last_ch == '\n' && ch != '\n' ) {
			insert_queue( q, ftell(input) - 1 );
		}
		last_ch = ch;
	}

	while( !empty_queue( q ) ) {
		loc = delete_queue( q );
		/* If this is the first line, print header */
		if ( first_line ) {
			first_line = FALSE;
			fprintf(output,"\n*** Last %d line(s) of file %s:\n",
				lines, file);
		}
		/* Now print the line */
		display_line( loc, input, output );
	}
	(void)fclose( input );

	/* if we printed any of the file, print a footer */
	if ( first_line == FALSE ) {
		fprintf(output,"*** End of file %s\n\n", condor_basename(file));
	}
}
예제 #16
0
파일: main.c 프로젝트: jwongv/cmps012b
void putinqueue (queue_ref queue, FILE *input, char *filename) {
   char buffer[1024];
   for (int linenr = 1; ; ++linenr) {
      char *linepos = fgets (buffer, sizeof buffer, input);
      if (linepos == NULL) break;
      linepos = strchr (buffer, '\n');
      if (linepos == NULL) {
         fflush (NULL);
         fprintf (stderr, "%s: %s[%d]: unterminated line\n",
                  execname, filename, linenr);
         fflush (NULL);
         exit_status = EXIT_FAILURE;
      }else {
         *linepos = '\0';
      }
      linepos = strdup (buffer);
      assert (linepos != NULL);
      insert_queue (queue, linepos);
   }
}
예제 #17
0
int
snd_seq_oss_write(struct seq_oss_devinfo *dp, const char __user *buf, int count, struct file *opt)
{
	int result = 0, err = 0;
	int ev_size, fmt;
	union evrec rec;

	if (! is_write_mode(dp->file_mode) || dp->writeq == NULL)
		return -ENXIO;

	while (count >= SHORT_EVENT_SIZE) {
		if (copy_from_user(&rec, buf, SHORT_EVENT_SIZE)) {
			err = -EFAULT;
			break;
		}
		if (rec.s.code == SEQ_FULLSIZE) {
			/* load patch */
			if (result > 0) {
				err = -EINVAL;
				break;
			}
			fmt = (*(unsigned short *)rec.c) & 0xffff;
			/* FIXME the return value isn't correct */
			return snd_seq_oss_synth_load_patch(dp, rec.s.dev,
							    fmt, buf, 0, count);
		}
		if (ev_is_long(&rec)) {
			/* extended code */
			if (rec.s.code == SEQ_EXTENDED &&
			    dp->seq_mode == SNDRV_SEQ_OSS_MODE_MUSIC) {
				err = -EINVAL;
				break;
			}
			ev_size = LONG_EVENT_SIZE;
			if (count < ev_size)
				break;
			/* copy the reset 4 bytes */
			if (copy_from_user(rec.c + SHORT_EVENT_SIZE,
					   buf + SHORT_EVENT_SIZE,
					   LONG_EVENT_SIZE - SHORT_EVENT_SIZE)) {
				err = -EFAULT;
				break;
			}
		} else {
			/* old-type code */
			if (dp->seq_mode == SNDRV_SEQ_OSS_MODE_MUSIC) {
				err = -EINVAL;
				break;
			}
			ev_size = SHORT_EVENT_SIZE;
		}

		/* insert queue */
		if ((err = insert_queue(dp, &rec, opt)) < 0)
			break;

		result += ev_size;
		buf += ev_size;
		count -= ev_size;
	}
	return result > 0 ? result : err;
}
예제 #18
0
int find_files(char* dirname, int socket, int *number, pthread_mutex_t *mtx)
{
        int return_code, i, err;
        DIR *dir_ptr;
        struct dirent entry;
        struct dirent *result;

        struct stat mybuf;
        char buf[256];

        if ((dir_ptr = opendir (dirname)) == NULL) {
                fprintf(stderr,"find files: couldn't open folder");
                return -1;
        }
        else {

                while( ( return_code = readdir_r(dir_ptr, &entry, &result) ) == 0 && result!=NULL) {

                        if (entry.d_ino==0) continue;
                        if ( strcmp(entry.d_name,".")==0 || strcmp(entry.d_name,"..")==0) continue;

                        strcpy(buf,dirname);
                        strcat(buf,"/");
                        strcat(buf, entry.d_name);

                        if ( stat (buf, & mybuf ) < 0) {
                                perror ( buf ) ; continue ; }

                        if (( mybuf.st_mode & S_IFMT ) == S_IFDIR )  // directory encountered
                        {
//                                printf("\ndirectory: %s\n", buf);
                                if ( find_files(buf, socket, number, mtx) == -1)
                                { fprintf(stderr,"find files recursion error"); return -1; }
                        }

                        else  // file encountered
                        {
                                QueueNode *node;
                                int filesize = (strlen(dirname)+strlen(entry.d_name)+2);

                                node = create_node();

                                node->number = number;
                                node->mutex = mtx;
                                node->clientSock = socket;
                                node->filesize = mybuf.st_size;
                                node->mode = mybuf.st_mode;

                                node->filename = malloc( filesize * sizeof(char) );
                                for (i=0; i<filesize; i++) node->filename[i] = '\0';
                                for (i=0; i<strlen(dirname); i++) node->filename[i] = dirname[i];
                                strcat(node->filename, "/");
                                strcat(node->filename, entry.d_name);

                                node->filename_size = filesize-1;

                                if (err = pthread_mutex_lock (& queue_lock )) {
                                    perror2 ("insert queue pthread_mutex_lock ", err ); exit (1); }

                                while(size_queue(queue) == queue_size) {
                                    pthread_cond_wait ( &insert , &queue_lock );
                                }

                                insert_queue(queue, node);
                                pthread_cond_signal ( &worker_cond );

                                color_text(client_color);
                                printf("[Client Thread: %ld]: Just added to queue: %s\n", pthread_self(), node->filename);
                                if (err = pthread_mutex_unlock (& queue_lock )) {
                                    perror2 ("insernt queue pthread_mutex_unlock ", err ); exit (1) ; }

//                                printf("file: %d,       %s/%s\n", mybuf.st_size ,dirname, entry.d_name);
                        }
                }
                closedir(dir_ptr);
        }
        return 0;
}
main()
{
	int i,v;
	int topo_order[MAX],indeg[MAX];
	int count;

	int j;

	create_graph();
	
	/*Find the indegree of each vertex*/
	for(i=0; i<n; i++)
	{
		indeg[i] = indegree(i);
		if( indeg[i] == 0 )
			insert_queue(i);
	}
	
	for(j=0; j<n; j++)
		printf("In(%d) = %d\t",j, indeg[j]);
	printf("\n");
	display_queue();	

	count = 0;
	while( !isEmpty_queue() && count<n )
	{
		v = delete_queue();
        printf("Delete %d and edges going from it\n",v);
		topo_order[++count] = v; /*Add vertex v to topo_order array*/
		/*Delete all edges going fron vertex v */
		for(i=0; i<n; i++)
		{
			if(adj[v][i]==1)
			{
				adj[v][i] = 0;
				indeg[i] = indeg[i]-1;
				if(indeg[i] == 0)
				{
					printf("Now vertex %d has zero indegree so insert it in the queue\n",i);
					insert_queue(i);
				}
			}
		}
		for(j=0; j<n; j++)
		{
			if(indeg[j]!=0)
				printf("In(%d) = %d\t",j, indeg[j]);
		}
		printf("\n");
		display_queue();
		STOP;
	}

	printf("count = %d\n",count);	
	if( count < n )
	{
		printf("No topological ordering possible, graph contains cycle\n");
		exit(1);
	}
	printf("Vertices in topological order are :\n");
	for(i=1; i<=count; i++)
		printf( "%d ",topo_order[i] );
	printf("\n");
}/*End of main()*/
예제 #20
0
pbs_queue *que_alloc(

  char *name,
  int   sv_qs_mutex_held)

  {
  static char *mem_err = (char *)"no memory";

  int        i;
  pbs_queue *pq;

  pq = (pbs_queue *)calloc(1, sizeof(pbs_queue));

  if (pq == NULL)
    {
    log_err(errno, __func__, mem_err);

    return(NULL);
    }

  pq->qu_qs.qu_type = QTYPE_Unset;

  pq->qu_mutex = (pthread_mutex_t *)calloc(1, sizeof(pthread_mutex_t));
  pq->qu_jobs = (struct all_jobs *)calloc(1, sizeof(struct all_jobs));
  pq->qu_jobs_array_sum = (struct all_jobs *)calloc(1, sizeof(struct all_jobs));
  
  if ((pq->qu_mutex == NULL) ||
      (pq->qu_jobs == NULL) ||
      (pq->qu_jobs_array_sum == NULL))
    {
    log_err(ENOMEM, __func__, mem_err);
    free(pq);
    return(NULL);
    }

  initialize_all_jobs_array(pq->qu_jobs);
  initialize_all_jobs_array(pq->qu_jobs_array_sum);
  pthread_mutex_init(pq->qu_mutex,NULL);
  lock_queue(pq, __func__, NULL, LOGLEVEL);

  snprintf(pq->qu_qs.qu_name, sizeof(pq->qu_qs.qu_name), "%s", name);

  insert_queue(&svr_queues,pq);
 
  if (sv_qs_mutex_held == FALSE)
    lock_sv_qs_mutex(server.sv_qs_mutex, __func__);
  server.sv_qs.sv_numque++;
  if (sv_qs_mutex_held == FALSE)
    unlock_sv_qs_mutex(server.sv_qs_mutex, __func__);

  /* set up the user info struct */
  pq->qu_uih = (user_info_holder *)calloc(1, sizeof(user_info_holder));
  initialize_user_info_holder(pq->qu_uih);

  /* set the working attributes to "unspecified" */

  for (i = 0; i < QA_ATR_LAST; i++)
    {
    clear_attr(&pq->qu_attr[i], &que_attr_def[i]);
    }

  /* Set route_retry_thread_id in case this is a routing queue */
  pq->route_retry_thread_id = -1;

  return(pq);
  }  /* END que_alloc() */