Example #1
0
void cl_initilize() {
	cl_int errcode;

	cl_platform_id platform[10];
	get_platforms(platform);

	cl_device_id devices[10];
	int platform_index = 0;
	get_devices(platform[platform_index], devices);

	int device_index = 0;
	show_device_info(devices[device_index]);

	context = clCreateContext(NULL, 1, &devices[device_index], NULL, NULL, &errcode);
	checkError(clCreateContext);

	queue = clCreateCommandQueue (context, devices[device_index], CL_QUEUE_PROFILING_ENABLE, &errcode); // третий параметр - свойства
	checkError(clCreateCommandQueue);

	char* source = "\n\
			  __kernel void sum(__global const uchar *src, __global uchar *trg, int m, int n)\n\
			  {\n\
			    int  i = get_global_id(0);\n\
			    int  j = get_global_id(1);\n\
 	            int SIdx = (i*n + (n-1 - j)) ;\n\
		    	int DIdx = (j*m + i) ;\n\
				if (i > m) return;\
				if (j > n) return;\
            	for (int c = 0; c < 3; c++)\n\
   		            trg[DIdx*3+c] = src[SIdx*3+c];\n\
			  }";
Example #2
0
/* Get the first device that matches the given device type and string.
 */
cl_device_id get_device(cl_platform_id platform, cl_device_type device_type, const char *device_string)
{
	cl_device_id *devices = NULL;
	cl_device_id device;
	char *name;
	int i;
	int len;
	int num;

	num = get_devices(platform, device_type, &devices);
	if (num < 1)
		return NULL;
	
	device = NULL;
	name = NULL;
	len = 0;
    for (i = 0; i < num; i++)
    {
		get_device_info(devices[i], CL_DEVICE_NAME, &name, &len);
	
		if (strstr(name, device_string))
        {
			device = devices[i];
			break;
        }
	}

	if (name != NULL)
		free(name);
	
	if (devices != NULL)
		free(devices);
	
	return device;
}
Example #3
0
/*
 * Print usage information, then terminate the program.
 */
void usage()
{
    char *devices[MAXDEV + 1];
    int ndev;

    printf("%s\n\n", copyright);
    printf("Usage:\n");
    printf("       sdwriter [-v] [-d device] sdcard.img\n");
    printf("\nArgs:\n");
    printf("       sdcard.img          Binary file with SD card image\n");
    printf("       -v                  Verify only\n");
    printf("       -d device           Use specified disk device\n");
    printf("       -D                  Debug mode\n");
    printf("       -h, --help          Print this help message\n");
    printf("       -V, --version       Print version\n");
    printf("\n");

    get_devices(devices, MAXDEV);
    if (! devices[0]) {
        printf("No target disk devices available.\n");
    } else {
        printf("Available disk devices:\n\n");
        for (ndev=0; devices[ndev]; ndev++) {
            printf("        %s\n", devices[ndev]);
        }
    }
    printf("\n");
    exit(0);
}
Example #4
0
static int get_num_devices(DevicesPtr devices=get_devices()) {
    int num = 0;
    for(ibv_device **iter=devices.get(); *iter; ++iter) {
        ++num;
    }
    return num;
}
Example #5
0
    /// Returns the build log.
    std::string build_log() const
    {
        device device = get_devices()[0];

        size_t size = 0;
        cl_int ret = clGetProgramBuildInfo(m_program,
                                           device.id(),
                                           CL_PROGRAM_BUILD_LOG,
                                           0,
                                           0,
                                           &size);
        if(ret != CL_SUCCESS){
            BOOST_THROW_EXCEPTION(runtime_exception(ret));
        }

        std::string value(size - 1, 0);
        ret = clGetProgramBuildInfo(m_program,
                                    device.id(),
                                    CL_PROGRAM_BUILD_LOG,
                                    size,
                                    &value[0],
                                    0);
        if(ret != CL_SUCCESS){
            BOOST_THROW_EXCEPTION(runtime_exception(ret));
        }

        return value;
    }
Example #6
0
    void Browser::Run(const char *pRessourcePath) {
        Init(pRessourcePath);

        // Disable auto render on format
        SetAutoRender(0);
#ifdef WIN32
        strcpy(currentPath, "c:/");
#else
        //        strcpy(currentPath, "uda0:/");
        handle = -1;
        char * s = NULL;
        int next_device_n = 0;
        
        next_device_n = get_devices(next_device_n, s);
        
        strcpy(currentPath, s);
        
        ScanDir();
#endif

        while (1) {
            RenderApp();
            Update();
        }
    }
static void ztex_disable(struct thr_info *thr)
{
	struct cgpu_info *cgpu;

	applog(LOG_ERR, "%s: Disabling!", thr->cgpu->device_ztex->repr);
	cgpu = get_devices(thr->cgpu->device_id);
	cgpu->deven = DEV_DISABLED;
	ztex_shutdown(thr);
}
Example #8
0
    /// Returns the device for the context. If the context contains multiple
    /// devices, the first is returned.
    device get_device() const
    {
        std::vector<device> devices = get_devices();

        if(devices.empty()) {
            return device();
        }

        return devices.front();
    }
Example #9
0
/*
 * Since we're getting potentially sensitive data (MAC addresses for all devices on the system),
 * hash all the MAC addresses to provide basic anonymity and security.
 */
char *internal_get_host_id(void)
{
    size_t i;
    unsigned char raw_md5[16];
    char *printable_md5;
    struct device *devices;
    void *ctx;

    devices = get_devices();
    if (!(devices))
        return NULL;

    printable_md5 = calloc(1, 37);
    if (!(printable_md5)) {
        free(devices);
        return NULL;
    }

    ctx = cl_hash_init("md5");
    if (!(ctx)) {
        for (i=0; devices[i].name != NULL; i++)
            free(devices[i].name);

        free(devices);
        free(printable_md5);

        return NULL;
    }

    for (i=0; devices[i].name != NULL; i++)
        cl_update_hash(ctx, devices[i].mac, sizeof(devices[i].mac));

    cl_finish_hash(ctx, raw_md5);

    for (i=0; devices[i].name != NULL; i++)
        free(devices[i].name);
    free(devices);

    for (i=0; i < sizeof(raw_md5); i++) {
        size_t len = strlen(printable_md5);
        switch (len) {
            case 8:
            case 13:
            case 18:
            case 23:
                printable_md5[len++] = '-';
                break;
        }

        sprintf(printable_md5+len, "%02x", raw_md5[i]);
    }

    return printable_md5;
}
Example #10
0
void recv_set(struct packet_t *packet) {
	uint8_t device_src,device_dst;
	application_t* app;
	uart_putstr_P(PSTR("recv_set()\r\n"));

	while (get_devices(packet,&device_src,&device_dst)) {
		app=app_get(device_dst);
		if (app == NULL) continue; 
		if (app->set == NULL) continue;
		app->set(packet);
	}
}
Example #11
0
/*
 * The command-line arguments to ucblinks are:
 *
 *	-r	specify a root relative to which ./devices and ./dev
 *		are used to create links.
 *
 *	-e	the awk-based ucblinks had a default rule-base and
 *		allowed alternate rule-bases with -e.  If the user
 *		specifies a rule-base we run the awk-based ucblinks
 *		and pass all the args to it.
 *
 *	-d	undocumented debug option (like the awk-based version);
 *		print what would be created, fixed, or is already correct.
 */
int
main(int argc, char **argv)
{
	int c;
	int err = 0;

	(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)
#define	TEXT_DOMAIN "SYS_TEST"
#endif
	(void) textdomain(TEXT_DOMAIN);

	progname = argv[0];	/* save program name for error messages */

	while ((c = getopt(argc, argv, "r:e:d")) != EOF) {
		switch (c) {
		case 'r':
			rootdir = optarg;
			break;
		case 'e':
			exec_script(argv);
			/* exec_script doesn't return */
			break;
		case 'd':
			debug = 1;
			break;
		case '?':
		default:
			err = 1;
			break;
		}
	}

	if (err || (optind != argc)) {
		(void) fprintf(stderr, gettext("usage: %s [ -r rootdir ] "
		    "[ -e rulebase ]\n"), progname);
		exit(1);
	}

	get_major_nums();

	set_depth();

	get_devices();

	get_dev_links();

	call_device_rules();

	return (0);
}
Example #12
0
/*
 * Ask for a name of the target device.
 */
const char *ask_device()
{
#define MAXDEV 9
    char *devices[MAXDEV + 1];
    char reply[100];
    int ndev;

    get_devices(devices, MAXDEV);
    if (! devices[0]) {
        printf("No removable USB disks avalable.\n");
        quit(0);
    }

    for (;;) {
        printf("\n");
        for (ndev=0; devices[ndev]; ndev++) {
            printf("  %c. %s\n", '1'+ndev, devices[ndev]);
        }
        printf("  q. Cancel\n");

        printf("\nSelect disk device ");
        if (ndev > 1)
            printf("(1-%c, q): ", '0'+ndev);
        else
            printf("(1, q): ");
        fflush(stdout);

        if (! fgets(reply, sizeof(reply), stdin)) {
            quit(0);
        }
        if (*reply == 'q' || *reply == 'Q') {
            printf("Cancelled.\n");
            quit(0);
        }
        if (*reply >= '1' && *reply < '1'+ndev) {
            char *devname = devices[*reply - '1'];
            char *p = strchr(devname, ' ');
            if (p)
                *p = 0;
            printf("\n");
            return devname;
        }
        printf("\nEnter 1");
        if (ndev > 1)
            printf("...%c", '0'+ndev);
        printf(" to select a device,\n");
        printf("or `Q' to cancel the operation.\n");
    }
}
Example #13
0
init_sys()
{
if (!init_system())
	return(0);

make_current_drawer();
strcpy(init_drawer, drawer);

/* OPENDUMP();    */
get_devices();

see_cmap();
find_colors();

return(1);
}
Example #14
0
void recv_get(struct packet_t *packet) {
	uint8_t device_src,device_dst;
	uint8_t len;
	application_t* app;

	struct packet_t *send_packet = get_tx_packet();

	while (get_devices(packet,&device_src,&device_dst)) {
		app=app_get(device_dst);
		set_devices(send_packet,device_dst,device_src);
		len=app->get(send_packet);
	//	if (len > 0) {
	//		data.remaining_len-=len;
	//	}
	}
	send(packet->network->src,VALUE,send_packet);
}
Example #15
0
    void Browser::Run(const char *pRessourcePath) {
        Init(pRessourcePath);

        // Disable auto render on format
        SetAutoRender(0);
#ifdef WIN32
        strcpy(currentPath, "c:/");
#else
        handle = 0;
        char path[2048];
        handle = get_devices(handle, path);
        
        strcpy(currentPath, path);

        ScanDir();
#endif

        while (1) {
            RenderApp();
            Update();
        }
    }
Example #16
0
static void
na_application_activate (GApplication *application)
{
  NAApplication *self = NA_APPLICATION (application);
  //G_APPLICATION_CLASS (na_application_parent_class)->startup (application);

  get_devices (self);

  introspection_data = g_dbus_node_info_new_for_xml (introspection_xml, NULL);
  g_assert (introspection_data != NULL);

  g_application_hold (application);

  guint owner_id = g_bus_own_name (G_BUS_TYPE_SYSTEM,
                                   NETWORK_ANALYZER_DBUS_NAME,
                                   G_BUS_NAME_OWNER_FLAGS_NONE,
                                   on_bus_acquired,
                                   on_name_acquired,
                                   on_name_lost,
                                   self,
                                   NULL);

  g_assert (owner_id > 0);
}
Example #17
0
    void Browser::Update() {
        
#ifdef WIN32
        W32Update();
#endif
        Hw::SystemPoll();

        get_controller_data(&ctrl, 0);
        {
            int up = 0;
            int down = 0;
            
            // button pressed
            if(ctrl.up && !old_ctrl.up){
                up++;
                lChange[0]=mftb();
            }
            else if (ctrl.down && !old_ctrl.down){
                down++;
                lChange[1]=mftb();
            }
            // button released
            if(!ctrl.up){
                lChange[0]=0;
            }
            if(!ctrl.down){
                lChange[1]=0;
            }
            
            uint64_t now = mftb();

            if(lChange[0]>0)
            if(tb_diff_msec(now,lChange[0])>250){
                static int uh=0;
                uh=!uh;
                if (uh) up++;
            }
            if(lChange[1]>0)
            if(tb_diff_msec(now,lChange[1])>250){
                static int dh=0;
                dh=!dh;
                if (dh) down++;
            }
            
            
            //if (get_controller_data(&ctrl, 0)) {
            if (up) {
                switch (panelSelected) {
                    case PANEL_FILE_LIST:
                        entrySelected--;
                        break;
                    case PANEL_ACTION:
                        actionSelected--;
                        break;
                }
            }

            if (down) {
                switch (panelSelected) {
                    case PANEL_FILE_LIST:
                        entrySelected++;
                        break;
                    case PANEL_ACTION:
                        actionSelected++;
                        break;
                }
            }
            if (ctrl.b && !old_ctrl.b) {
                switch (panelSelected) {
                    case PANEL_FILE_LIST:
                        append_dir_to_path(currentPath, "..");
                        ScanDir();
                        break;
                }
            }
            if (ctrl.back && !old_ctrl.back) {
#ifdef LIBXENON
                switch (panelSelected) {
                    case PANEL_FILE_LIST:
                        char path[2048];
                        
                        handle = get_devices(handle, path);

                        strcpy(currentPath, path);
                        ScanDir();
                        break;
                }
#endif
            }
            if
                (
                    (ctrl.start && !old_ctrl.start) || (ctrl.a && !old_ctrl.a)
                    ) {
                switch (panelSelected) {
                    case PANEL_FILE_LIST:
                    {
                        if (vEntry.size() == 0)
                            break;

                        FileEntry currentEntry = vEntry.at(entrySelected);

                        if (currentEntry.type == 1) {
                            append_dir_to_path(currentPath, (char*) currentEntry.name.c_str());
                            ScanDir();
                        } else {
                            sprintf(currentFile, "%s/%s", currentPath, currentEntry.name.c_str());
                            if (ActionLaunchFile != NULL)
                                ActionLaunchFile(currentFile);
                        }
                        break;
                    }
                    case PANEL_ACTION:
                    {
                        if (nbAction == 0)
                            break;

                        // Exec action ...
                        //FileEntry currentEntry = vEntry.at(entrySelected);
                        lpBrowserActionEntry currentAction = vAction[actionSelected];
                        if (currentAction != NULL && currentAction->action != NULL) {
                            currentAction->param = (void*) currentPath;
                            //currentAction->param = 
                            currentAction->action(currentAction);
                        }
                        break;
                    }
                }
            }

            if (ctrl.left && !old_ctrl.left) {
                //if(panelSelected!=PANEL_PROGRESS)
                panelSelected--;
            }
            if (ctrl.right && !old_ctrl.right) {
                //if(panelSelected!=PANEL_PROGRESS)
                panelSelected++;
            }

            // clamp ...
            CLAMP(entrySelected, 0, vEntry.size() - 1);
            CLAMP(actionSelected, 0, nbAction - 1);
            CLAMP(panelSelected, 0, 1);


            // Save the old value
            old_ctrl = ctrl;

            // Erase for the big loop
            memset(&ctrl, 0, sizeof (struct controller_data_s));
        }


    }
int start_simulation(void)
{
    cl_device_id *dev;
	cl_uint devc;
    cl_context context;
    cl_command_queue *cmd_queue;
    cl_mem src, dst, wdth, hght, *offy;
    cl_int err;
    cl_kernel kern;
    cl_program prog;
	cl_platform_id pform;
    size_t rows, columns, runs, print_each = 0, offsetx, offsety, *y, swapoffy;
	int gui_enabled, platform, device;
    unsigned int *buff0;
    unsigned int i;
	struct dispatcher_context *c;
	int random;
	char fname[1024];
	cl_uint cqc;
    
#if 1
    
	do
	{
		printf("Width: ");
		scanf(SZTF, &columns);
        
		if (columns % 32)
		{
			printf("Width must be a multiple of 32\n");
			continue;
		}
        
		if (columns == 0)
		{
			printf("Width must be > 0\n");
			continue;
		}
        
		break;
	}
	while (true);
    
	do
	{
		printf("Height: ");
		scanf(SZTF, &rows);
        
		if (rows == 0)
		{
			printf("Width must be > 0\n");
			continue;
		}
        
		break;
	}
	while (true);
    
    printf("Runs: ");
    scanf(SZTF, &runs);
    
	printf("Random? ");
	scanf("%d", &random);
    
	if (!random)
	{
		printf("File name: ");
		scanf("%s", fname);
        
		printf("Offset X: ");
		scanf(SZTF, &offsetx);
        
		printf("Offset Y: ");
		scanf(SZTF, &offsety);
	}
    
	printf("GUI? ");
	scanf("%d", &gui_enabled);
    
	if (!gui_enabled)
	{
		printf("Print after run: ");
		scanf(SZTF, &print_each);
	}
    
	printf("Platform index: ");
	scanf("%d", &platform);
    
	printf("Device index (-1 for all): ");
	scanf("%d", &device);
    
	do
	{
		printf("Swap offset: ");
		scanf(SZTF, &swapoffy);
        
		if (swapoffy == 0) swapoffy = rows;
        
		if (rows % swapoffy != 0)
		{
			printf("Swap offset must be a factor of the row count\n");
			continue;
		}
        
		break;
	}
	while (true);
#else
    columns = 512;
    rows = 512;
    runs = 1000;
	gui_enabled = 1;
    print_each = 0;
	random = 1;
    offsetx = 0;
    offsety = 0;
	platform = 0;
	device = 0;
	swapoffy = rows;
#endif
    
    err = get_devices(&dev, &devc, &pform, platform, device);
    if (err)
        return err;
    
    err = initialize_context_cmd_queue(dev, devc, pform, &context, &cmd_queue, &cqc);
    if (err)
        return err;
    
    err = load_kernel(context, dev, devc, &prog, &kern);
    if (err)
        return err;
    
    buff0 = (unsigned int*)malloc(rows * (columns / 8));
    if (!buff0)
        return -1;
    
	if (random)
	{
		srand((unsigned int)time(NULL));
		for (i = 0; i < (rows * (columns / 8)) / 4; i++)
		{
		    buff0[i] = rand() | (rand() << 16);
		}
	}
	else
	{
		memset(buff0, 0, rows * (columns / 8));
		if (!load_file_to_buffer(buff0, fname, offsetx, offsety, columns, rows))
			return -1;
	}
    
	err = compute_buffer_sizes(context, cmd_queue, cqc, kern, columns, rows, swapoffy, &y);
	if (err)
		return err;
    
    err = create_buffers(context, swapoffy * (columns / 8), columns, 
		swapoffy, &src, &dst, &wdth, &hght, &offy, y, buff0, devc);
    if (err)
        return err;
    
	if (gui_enabled)
	{
		if (!initialize_window())
			return -1;
	}
    
	c = (struct dispatcher_context *)malloc(sizeof(*c));
	if (!c)
		return -1;
    
	c->cmd_queue = cmd_queue;
	c->cqc = cqc;
	c->kern = kern;
	c->columns = columns;
	c->rows = rows;
	c->print_each = print_each;
	c->runs = runs;
	c->gui_enabled = gui_enabled;
	c->buff0 = buff0;
	c->src = src;
	c->dst = dst;
	c->wdth = wdth;
	c->hght = hght;
	c->offy = offy;
	c->y = y;
	c->swapoffy = swapoffy;
	c->context = context;
    c->win_height = rows;
    
	return start_dispatcher(c);
}
Example #19
0
 /// Returns the build log.
 std::string build_log() const
 {
     return get_build_info<std::string>(CL_PROGRAM_BUILD_LOG, get_devices().front());
 }