/*
function to be called
base_pointer the base pointer to a element
number_of_elements the number of elements to sort
width offset of an element
compar_func the comparison function
//*/
void quicksort(void* base_pointer
, size_t number_of_elements
, size_t width
, int (*compar_func)(const void*, const void *))
{
static int number_of_processors = -1;
/*
get the number of processors and do some performance related settings
//*/
if(number_of_processors == -1){
// get the number of processors (= cpu's)
number_of_processors = sysconf( _SC_NPROCESSORS_ONLN);
// lwp for each cpu
if((number_of_processors > 1) && (pthread_getconcurrency() < number_of_processors))
pthread_setconcurrency(number_of_processors);
// thread count not to exceed THR_PER_LWP per lwp
threads_avail = (number_of_processors == 1) ? 0 : (number_of_processors * THR_PER_LWP);
}
/*
set up the sorting arguments
//*/
sort_args_t sort_args;
sort_args.sortargs_base = base_pointer;
sort_args.sortargs_number_of_elements = number_of_elements;
sort_args.sortargs_width = width;
sort_args.sortargs_compar_func = compar_func;
// start sorting
_quicksort(&sort_args);
}
int main(int argc, char** argv)
{
grid_size = GRID_SIZE;
nthreads = NTHREADS;
if(argc>=2){
nthreads = atoi(argv[1]);
grid_size = atoi(argv[2]);
}
omp_set_num_threads(nthreads);
/*#pragma omp parallel
{
cout<<"Hello"<<endl;
}*/
//int i=0;
/*matrix<double > temp;
temp.resize(10,10);
#pragma omp parallel for
for(int i=0;i<10;i++)
for(int j=0;j<10;j++)
cout<<temp(i,j);
*/
glutInit(&argc, argv);
initMain ();
int i=pthread_getconcurrency();
char windowName[]=" Liquid_Simulator-LevelSet+Surface" ;
openGlutWindow(windowName);
glutMainLoop();
return 0;
}
///////////////////////////////////////////////////////////////////////
//main, setup and execution of environment
int main(int argc, char **argv) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
glutInitWindowPosition(100,100);
glutInitWindowSize(568,320);
glutCreateWindow("Computer Graphics");
glutDisplayFunc(renderScene);
glutIdleFunc(renderScene);
glutReshapeFunc(changeSize);
glutKeyboardFunc(processNormalKeys);
glutMouseFunc(mouseClick);
glutMotionFunc(mouseMotion);
glEnable(GL_DEPTH_TEST);
glClearColor(0.0,0.0,0.0,1.0);
glewInit();
if (GLEW_ARB_vertex_shader && GLEW_ARB_fragment_shader)
printf("Ready for GLSL\n");
else {
printf("No GLSL support\n");
exit(1);
}
if (glewIsSupported("GL_VERSION_3_3"))
printf("Ready for OpenGL 3.3\n");
else {
printf("OpenGL 3.3 not supported\n");
exit(1);
}
if (GLEW_ARB_vertex_shader && GLEW_ARB_fragment_shader && GL_EXT_geometry_shader4)
printf("Ready for GLSL - vertex, fragment, and geometry units\n");
else {
printf("Not totally ready :( \n");
exit(1);
}
if (GL_ARB_fragment_program && GL_ARB_vertex_program && GL_EXT_framebuffer_object)
printf("Ready for FrameBuffer\n");
else {
printf("Not totally ready :( \n");
exit(1);
}
initialize();
#ifdef __linux__
int i=pthread_getconcurrency();
#endif
setShaders();
glutMainLoop();
return EXIT_SUCCESS;
}
int
do_test (void)
{
int c = pthread_getconcurrency ();
if (c != 0)
{
puts ("initial concurrencylevel wrong");
exit (1);
}
if (pthread_setconcurrency (1) != 0)
{
puts ("setconcurrency failed");
exit (1);
}
c = pthread_getconcurrency ();
if (c != 1)
{
puts ("getconcurrency didn't return the value previous set");
exit (1);
}
int e = pthread_setconcurrency (-1);
if (e == 0)
{
puts ("setconcurrency of negative value didn't failed");
exit (1);
}
if (e != EINVAL)
{
puts ("setconcurrency didn't return EINVAL for negative value");
exit (1);
}
c = pthread_getconcurrency ();
if (c != 1)
{
puts ("invalid getconcurrency changed level");
exit (1);
}
return 0;
}
int
ldap_pvt_thread_get_concurrency(void)
{
#ifdef HAVE_PTHREAD_GETCONCURRENCY
return pthread_getconcurrency();
#elif defined(HAVE_THR_GETCONCURRENCY)
return thr_getconcurrency();
#else
return 0;
#endif
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
init ();
int i=pthread_getconcurrency();
char windowName[]=" Liquid_Simulator-LevelSet+Surface" ;
openGlutWindow(windowName);
glutMainLoop();
return 0;
}
void bbcp_Thread_MT(int mtval)
{
#ifdef SUN
#ifndef SUN6 // Ranch version added this #ifndef SUN6
int rc, oldmt = pthread_getconcurrency(), newmt = mtval;
while(mtval)
if ((rc = pthread_setconcurrency(mtval)) && rc == EAGAIN) mtval--;
else break;
DEBUG("MT set rc=" <<rc <<" omt=" <<oldmt <<" rmt=" <<newmt <<" nmt=" <<mtval);
#endif
#endif
}
void *POSIX_Init(
void *argument
)
{
int sc;
TEST_BEGIN();
puts( "Init: pthread_getconcurrency - initial value of 0" );
sc = pthread_getconcurrency();
rtems_test_assert( sc == 0 );
puts( "Init: pthread_setconcurrency - set value to 2" );
sc = pthread_setconcurrency( 2 );
rtems_test_assert( sc == 0 );
puts( "Init: pthread_getconcurrency - confirm new value of 2" );
sc = pthread_getconcurrency();
rtems_test_assert( sc == 2 );
TEST_END();
rtems_test_exit(0);
}
int main(int argc, char **argv) {
int basura = pthread_getconcurrency();
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA|GLUT_DEPTH);
glutInitWindowSize(rHeight,rWidth);
glutCreateWindow("Bloc 3");
init();
glEnable(GL_DEPTH_TEST);
glutDisplayFunc(refresh);
glutReshapeFunc(resize);
glutMouseFunc(mouseClicked);
glutMotionFunc(mouseMoved);
glutKeyboardFunc(teclado);
glutIdleFunc(update);
glutMainLoop();
return 0;
}
static int print_thread_attr(pthread_attr_t *attr)
{
if (attr == NULL)
{
return THREAD_ATTR_FAILED;
}
int detach_state = 0;
int ret = 0;
char *stack_addr = NULL;
size_t stack_size = 0;
size_t guard_size = 0;
ret = pthread_attr_getdetachstate(attr, &detach_state);
if (detach_state == PTHREAD_CREATE_JOINABLE)
{
printf("Thread detach state: JOINABLE\n");
}
else if (detach_state == PTHREAD_CREATE_DETACHED)
{
printf("Thread detach state: DETACHED\n");
}
ret = pthread_attr_getstack(attr, (void**)&stack_addr, &stack_size);
printf("stack_addr:%p, stack_size:%zd\n", stack_addr, stack_size);
ret = pthread_attr_getstacksize(attr, &stack_size);
printf("stack size:%#x\n", stack_size);
ret = pthread_attr_getguardsize(attr, &guard_size);
printf("guard size:%#x\n", guard_size);
ret = pthread_getconcurrency();
printf("concurrency is %d\n", ret);
return THREAD_ATTR_OK;
}
int main(int argc, char** argv)
{
grid_size = GRID_SIZE;
nthreads = NTHREADS;
if(argc>=2){
nthreads = atoi(argv[1]);
grid_size = atoi(argv[2]);
}
omp_set_num_threads(nthreads);
struct timeval tt1, tt2;
initMain();
int i=pthread_getconcurrency();
int it=0;
int ni= 0;
while(ni++<NO_OF_ITERATIONS){
gettimeofday(&tt1, NULL);
animate();
gettimeofday(&tt2, NULL);
int milliSeconds = (tt2.tv_sec - tt1.tv_sec) * 1000 + (tt2.tv_usec - tt1.tv_usec)/1000;
cout<<"Iteration "<<it<<" : "<<milliSeconds<<"ms"<<endl<<endl;
it++;
}
return 0;
}
void X11OpenGLWindow::enableOpenGL()
{
m_data->m_glc = glXCreateContext(m_data->m_dpy, m_data->m_vi, NULL, GL_TRUE);
glXMakeCurrent(m_data->m_dpy, m_data->m_win, m_data->m_glc);
const GLubyte* ven = glGetString(GL_VENDOR);
printf("GL_VENDOR=%s\n", ven);
const GLubyte* ren = glGetString(GL_RENDERER);
printf("GL_RENDERER=%s\n",ren);
const GLubyte* ver = glGetString(GL_VERSION);
printf("GL_VERSION=%s\n", ver);
const GLubyte* sl = glGetString(GL_SHADING_LANGUAGE_VERSION);
printf("GL_SHADING_LANGUAGE_VERSION=%s\n", sl);
//Access pthreads as a workaround for a bug in Linux/Ubuntu
//See https://bugs.launchpad.net/ubuntu/+source/nvidia-graphics-drivers-319/+bug/1248642
int i=pthread_getconcurrency();
printf("pthread_getconcurrency()=%d\n",i);
// const GLubyte* ext = glGetString(GL_EXTENSIONS);
// printf("GL_EXTENSIONS=%s\n", ext);
}
int main(int argc, char* argv[])
{
printf("Program %s Begin\n", argv[0]);
struct tms begintime;
clock_t begreal = times(&begintime);
struct sigaction act, oact;
sigemptyset(&act.sa_mask);
act.sa_flags = SA_SIGINFO;
act.sa_sigaction = sigaction_handle_fun;
sigaction(SIGTERM, &act, &oact);
pthread_t pthreadid = pthread_self();
printf("pthreadid:%u\n", pthreadid);
pthread_mutex_init (&(gcounter.m_mutex), NULL);
gcounter.m_cout = 0;
pthread_attr_t pthreadattr;
pthread_attr_init(&pthreadattr);
size_t pthreadstacksize;
pthread_attr_getstacksize(&pthreadattr, &pthreadstacksize);
printf("pthreadstacksize:%u\n", pthreadstacksize);
printf("pthread_getconcurrency:%d\n", pthread_getconcurrency());
pthread_t newpthreadid;
char* charg = "000 pass to pthread";
int pcreateret = pthread_create(&newpthreadid, NULL, pthread_fun0, charg);
if(pcreateret != 0)
{
perror("pthread_create error");
}
else
{
printf("newpthreadid:%u\n", newpthreadid);
}
pthread_t newpthreadid1;
char* charg1 = "100 pass to pthread";
int pcreateret1 = pthread_create(&newpthreadid1, NULL, pthread_fun1, charg);
if(pcreateret1 != 0)
{
perror("pthread_create error");
}
else
{
printf("newpthreadid:%u\n", newpthreadid1);
}
void* pret;
pthread_join(newpthreadid, &pret);
pthread_join(newpthreadid1, &pret);
char chcwdbuf[100];
if(getcwd (chcwdbuf, 100) == NULL)
{
perror("getcwd error");
}
else
{
printf("getcwd %s\n", chcwdbuf);
}
printf("input characters:\n");
int c;
while( (c = getc(stdin)) != EOF)
{
if(putc(c, stdout) == EOF)
{
perror("putc error");
}
}
time_t t = time(NULL);
struct tm* localtm = localtime(&t);
printf("Time:%s\n", asctime(localtm));
printf("getlogin:%s\n", getlogin());
atexit(atexit_fun1);
atexit(atexit_fun2);
printf("getpid():%d\n", getpid());
pid_t pid;
if( (pid = fork()) < 0)
{
perror("fork error\n");
}
else if(pid == 0)
{
printf("great this is child process created by fork \n");
printf("getpid():%d\n", getpid());
printf("getppid():%d\n", getppid());
printf("getpgrp():%d\n", getpgrp());
}
else
{
printf("parent process is here.\n");
}
/* extern char** environ; */
/* char** env = environ; */
/* while(*env) */
/* { */
/* ++env; */
/* printf("%s\n", *env); */
/* } */
/* while(environ[]) */
/* { */
/* printf(""); */
/* } */
/* while(!GbStop) */
/* /\* while(1) //C99 define true C89 didn't define *\/ */
/* { */
/* } */
struct tms endtime;
clock_t endreal = times(&endtime);
printf("real:%f\n"
"user:%f\n"
"sys:%f\n",
(float)(endreal-begreal)/CLOCKS_PER_SEC, (float)(endtime.tms_utime-begintime.tms_utime)/CLOCKS_PER_SEC, (float)(endtime.tms_stime-begintime.tms_stime)/CLOCKS_PER_SEC );
return 0;
}
int Thread::concurrency_priv() { return pthread_getconcurrency(); }
void junk() {
int i;
i=pthread_getconcurrency();
};
int main()
{
int8_t x;
pid_t pid;
pthread_t tid;
pthread_key_t tkey;
char *s, c;
struct timespec ns = {.tv_nsec=0};
unsigned int i, nr_fun, failed;
int err, ret[2]= {0,0}, stat;
pthread_rwlock_t tlock = PTHREAD_RWLOCK_INITIALIZER;
const char *function[] = {
"pthread_create",
"pthread_cancel",
"pthread_once",
"pthread_setspecific",
"pthread_key_delete",
"pthread_join",
"pthread_atfork",
"pthread_sigmask",
"pthread_setschedprio",
"pthread_setconcurrency",
"pthread_detach",
"pthread_key_create",
"pthread_rwlock_unlock",
"pthread_kill",
//"pthread_equal",
};
struct {
unsigned int
kill:1,
wait:1;
} error, no_error = {.wait=0};
struct sigaction act = {.sa_handler=handle, .sa_flags=SA_NODEFER};
failed = 0;
for (i=0; i < (nr_fun=sizeof(function)/sizeof(*function)); ++i) {
pipe(pfd);
memset(&error, 0, sizeof(error));
if (!(pid = fork())) {
close(pfd[0]);
blocked = 0; //wrappers set it to 1 after saving env
sigaction(SIGTERM, &act, NULL);
sigaction(SIGABRT, &act, NULL);
pthread_create(&tid, NULL, thread, block);
switch (i) {
case 0:
err = wrap_pthread_create(&tid, NULL, thread, NULL);
break;
case 1:
err = wrap_pthread_cancel(tid);
break;
case 2:
err = wrap_pthread_once(
(pthread_once_t []) {
PTHREAD_ONCE_INIT
},
block
);
break;
case 3:
if (!pthread_key_create(&tkey, NULL)) {
err = wrap_pthread_setspecific(tkey, NULL);
pthread_key_delete(tkey);
} else
err = -3;
break;
case 4:
//key creation(inicialization) done in the wrapper:
err = wrap_pthread_key_delete(tkey);
break;
case 5:
err = wrap_pthread_join(tid, NULL);
break;
#ifndef GLIBC
case 6:
err = wrap_pthread_atfork(NULL, NULL, NULL);
break;
#endif
case 7:
err = wrap_pthread_sigmask(SIG_UNBLOCK, NULL, NULL);
break;
#ifndef MUSL
case 8:
err = wrap_pthread_setschedprio(
tid,
sched_get_priority_min(sched_getscheduler(0))
);
break;
#endif
case 9:
err = wrap_pthread_setconcurrency(pthread_getconcurrency());
break;
case 10:
err = wrap_pthread_detach(tid);
break;
case 11:
//key deletion done in the wrapper:
err = wrap_pthread_key_create(&tkey, NULL);
break;
case 12:
if (!pthread_rwlock_init(&tlock, NULL)) {
err = wrap_pthread_rwlock_unlock(&tlock);
pthread_rwlock_destroy(&tlock);
}
else
err = -2;
break;
case 13:
err = wrap_pthread_kill(tid, 0);
break;
/*
case 14:
err = wrap_pthread_equal(tid, tid);
break;
*/
default:
blocked = 0;
close(pfd[1]);
err = -2;
break;
}
return err;
}
if (!pid) {
fprintf(stdout, "BUG: child i=%d escaped!\n", i);
exit(0); //exit/contain child
} else if (pid == -1) {
close(pfd[1]);
close(pfd[0]);
fprintf(stderr,
"A call to fork() nr %d/%d yielded -1 (errno=%s)!\n",
i+1, nr_fun, (s = e_name(errno))
);
free(s);
failed += 1;
} else {
close(pfd[1]);
read(pfd[0], &c, 1); //wait for the child to become ready
close(pfd[0]);
//Send SIGABRT to child in delays of <NANOSLEEP_MAX/100,0> microsec:
ns.tv_nsec = NANOSLEEP_MAX;
while(
(ret[0] = kill(pid, SIGABRT)) == 0
&& (ret[1] = waitpid(pid, &stat, WNOHANG)) == 0
&& (ns.tv_nsec -= 100)
)
nanosleep(&ns, NULL);
//let child's function out of its loop/blocked state
kill(pid, SIGTERM);
if (!ns.tv_nsec)
waitpid(pid, &stat, 0);
//Process errors:
s = e_name(errno);
error.kill = (ret[0] != 0);
error.wait = (ret[1] != 0 && ret[1] != pid);
if (memcmp(&error, &no_error, sizeof(error))) {
++failed;
if (error.kill)
fprintf(stderr,
"A call to kill() returned %d, errno=%s\n",
ret[0], s
);
if (error.wait)
fprintf(stderr,
"A call to waitpid() returned %d, errno=%s\n",
ret[1], s
);
} else if (WIFEXITED(stat)) {
if ((x = WEXITSTATUS(stat))) {
++failed;
if (x == -2)
fprintf(stderr,
"%s() and/or its dependencies missing!\n",
function[i]
);
else if (x == -3)
fprintf(stderr,
"%s() was not tested - its dependency failed\n",
function[i]
);
else if (x) {
free(s);
s = e_name(x);
fprintf(stderr, "%s() returned %s\n", function[i], s);
}
}
} else {
fprintf(stderr, "%s()'s host process crashed!\n", function[i]);
if (WIFSIGNALED(stat))
fprintf(stderr,
"\tTerminating signal: %d\n",
(int)WTERMSIG(stat)
);
}
free(s);
}
}
return failed;
}
/**
** Signal handler. Upon receiving the first SIGTERM it unsets blocked, longjmps
** Otherwise - on another signal or if blocked is unset - it simply returns
**/
static void handle(int sig)
{
if (sig == SIGTERM) {
if(blocked) {
blocked = 0;
longjmp(env, 1);
}
//else {printf("BUG: Misplaced SIGTERM!\n");} //-----
}
}
///waits for blocked to be unset by a signal[!] via the signal handler, returns
static void block(void)
{
while(blocked)
sched_yield(); //can't use pause() - handle() doesn't return on SIGTERM
sleep(3);
printf("exit block()\n");//---
}
/**
** Establishes the function passed to it as a thread cancellation handler and
** calls it. Thus, if the executing thread is canceled, the said function will
** still have to be executed before the thread is terminated.
** \param fun a void* cast of (void (*)()) or NULL (only return)
**/
static void* thread(void *fun)
{
if (fun != NULL) {
pthread_cleanup_push(fun, NULL);
((void (*)())fun)();
pthread_cleanup_pop(0);
}
return NULL;
}
///<Wrappers start here: They take the same arguments as the functions they
///<call but install the SIGTERM handler and optionally loop until it's received
static int wrap_pthread_create(pthread_t *restrict thread,
const pthread_attr_t *restrict attr,
void *(*start_routine)(void*),
void *restrict arg)
{
WRAP_START
while (!err)
err = pthread_create(thread, attr, start_routine, arg);
WRAP_END
}
static int wrap_pthread_cancel(pthread_t thread)
{
WRAP_START
err = pthread_cancel(thread);
WRAP_END
}
void X11OpenGLWindow::enableOpenGL()
{
if (forceOpenGL3)
{
// Get the default screen's GLX extension list
const char *glxExts = glXQueryExtensionsString( m_data->m_dpy,
DefaultScreen( m_data->m_dpy ) );
// NOTE: It is not necessary to create or make current to a context before
// calling glXGetProcAddressARB, unless we dynamically load OpenGL/GLX/X11
glXCreateContextAttribsARBProc glXCreateContextAttribsARB = 0;
glXCreateContextAttribsARB = (glXCreateContextAttribsARBProc)
glXGetProcAddressARB( (const GLubyte *) "glXCreateContextAttribsARB" );
GLXContext ctx = 0;
// Install an X error handler so the application won't exit if GL 3.0
// context allocation fails.
//
// Note this error handler is global. All display connections in all threads
// of a process use the same error handler, so be sure to guard against other
// threads issuing X commands while this code is running.
ctxErrorOccurred = false;
int (*oldHandler)(Display*, XErrorEvent*) =
MyXSetErrorHandler(&ctxErrorHandler);
// Check for the GLX_ARB_create_context extension string and the function.
// If either is not present, use GLX 1.3 context creation method.
if ( !isExtensionSupported( glxExts, "GLX_ARB_create_context" ) ||
!glXCreateContextAttribsARB )
{
printf( "glXCreateContextAttribsARB() not found"
" ... using old-style GLX context\n" );
ctx = glXCreateNewContext( m_data->m_dpy, m_data->m_bestFbc, GLX_RGBA_TYPE, 0, True );
}
// If it does, try to get a GL 3.0 context!
else
{
int context_attribs[] = {
GLX_CONTEXT_MAJOR_VERSION_ARB ,3,
GLX_CONTEXT_MINOR_VERSION_ARB, 2,
GLX_CONTEXT_FLAGS_ARB, GLX_CONTEXT_DEBUG_BIT_ARB,
GLX_CONTEXT_PROFILE_MASK_ARB, GLX_CONTEXT_CORE_PROFILE_BIT_ARB,None
};
/*
int context_attribs[] =
{
GLX_CONTEXT_MAJOR_VERSION_ARB, 3,
GLX_CONTEXT_MINOR_VERSION_ARB, 2,
//GLX_CONTEXT_FLAGS_ARB , GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB,
None
};
*/
printf( "Creating context\n" );
ctx = glXCreateContextAttribsARB( m_data->m_dpy, m_data->m_bestFbc, 0,
True, context_attribs );
// Sync to ensure any errors generated are processed.
MyXSync( m_data->m_dpy, False );
if ( !ctxErrorOccurred && ctx )
printf( "Created GL 3.0 context\n" );
else
{
// Couldn't create GL 3.0 context. Fall back to old-style 2.x context.
// When a context version below 3.0 is requested, implementations will
// return the newest context version compatible with OpenGL versions less
// than version 3.0.
// GLX_CONTEXT_MAJOR_VERSION_ARB = 1
context_attribs[1] = 1;
// GLX_CONTEXT_MINOR_VERSION_ARB = 0
context_attribs[3] = 0;
ctxErrorOccurred = false;
printf( "Failed to create GL 3.0 context"
" ... using old-style GLX context\n" );
ctx = glXCreateContextAttribsARB( m_data->m_dpy, m_data->m_bestFbc, 0,
True, context_attribs );
}
}
// Sync to ensure any errors generated are processed.
MyXSync( m_data->m_dpy, False );
// Restore the original error handler
MyXSetErrorHandler( oldHandler );
if ( ctxErrorOccurred || !ctx )
{
printf( "Failed to create an OpenGL context\n" );
exit(1);
}
// Verifying that context is a direct context
if ( ! glXIsDirect ( m_data->m_dpy, ctx ) )
{
printf( "Indirect GLX rendering context obtained\n" );
}
else
{
printf( "Direct GLX rendering context obtained\n" );
}
printf( "Making context current\n" );
glXMakeCurrent( m_data->m_dpy, m_data->m_win, ctx );
m_data->m_glc = ctx;
} else
{
m_data->m_glc = glXCreateContext(m_data->m_dpy, m_data->m_vi, NULL, GL_TRUE);
glXMakeCurrent(m_data->m_dpy, m_data->m_win, m_data->m_glc);
}
#ifdef GLEW_INIT_OPENGL11_FUNCTIONS
{
GLboolean res = glewOpenGL11Init();
if (res==0)
{
printf("glewOpenGL11Init OK!\n");
} else
{
printf("ERROR: glewOpenGL11Init failed, exiting!\n");
exit(0);
}
}
#endif //GLEW_INIT_OPENGL11_FUNCTIONS
const GLubyte* ven = glGetString(GL_VENDOR);
printf("GL_VENDOR=%s\n", ven);
const GLubyte* ren = glGetString(GL_RENDERER);
printf("GL_RENDERER=%s\n",ren);
const GLubyte* ver = glGetString(GL_VERSION);
printf("GL_VERSION=%s\n", ver);
const GLubyte* sl = glGetString(GL_SHADING_LANGUAGE_VERSION);
printf("GL_SHADING_LANGUAGE_VERSION=%s\n", sl);
//Access pthreads as a workaround for a bug in Linux/Ubuntu
//See https://bugs.launchpad.net/ubuntu/+source/nvidia-graphics-drivers-319/+bug/1248642
int i=pthread_getconcurrency();
printf("pthread_getconcurrency()=%d\n",i);
// const GLubyte* ext = glGetString(GL_EXTENSIONS);
// printf("GL_EXTENSIONS=%s\n", ext);
}
