Changeset 573 for trunk/libs/libpthread
- Timestamp:
- Oct 5, 2018, 12:21:52 AM (6 years ago)
- Location:
- trunk/libs/libpthread
- Files:
-
- 2 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/libs/libpthread/pthread.c
r477 r573 31 31 #include <syscalls_numbers.h> 32 32 33 #define PTHREAD_MUTEX_DEBUG 0 34 #define PTHREAD_BARRIER_DEBUG 1 33 #define PTHREAD_BARRIER_DEBUG 0 35 34 36 35 //////////////////////////////////////////////////////////////////////////////////////////// … … 307 306 if ( node->parent != NULL ) sqt_barrier_decrement( node->parent ); 308 307 309 // reset the current node310 node->sense = expected;311 node->count = node->arity;312 313 308 #if PTHREAD_BARRIER_DEBUG 314 309 printf("\n[BARRIER] %s : core[%x,%d] reset SQT barrier node %x :\n" … … 317 312 node->level , node->arity , node->sense , node->count ); 318 313 #endif 314 // reset the current node 315 node->sense = expected; 316 node->count = node->arity; 317 319 318 return; 320 319 } … … 374 373 } 375 374 376 mutex->current = 0; 377 mutex->free = 0; 378 379 #if PTHEAD_MUTEX_DEBUG 380 unsigned int cxy; 381 unsigned int lid; 382 get_core( &cxy , &lid ); 383 printf("\n[MUTEX DEBUG] %s : core[%x,%d] initializes mutex %x\n", 384 __FUNCTION__, cxy, lid, mutex ); 385 #endif 386 387 return 0; 375 return hal_user_syscall( SYS_MUTEX, 376 (reg_t)mutex, 377 MUTEX_INIT, 378 0, 0 ); 379 } 380 381 //////////////////////////////////////////////////// 382 int pthread_mutex_destroy( pthread_mutex_t * mutex ) 383 { 384 return hal_user_syscall( SYS_MUTEX, 385 (reg_t)mutex, 386 MUTEX_DESTROY, 387 0, 0 ); 388 388 } 389 389 … … 391 391 int pthread_mutex_lock( pthread_mutex_t * mutex ) 392 392 { 393 unsigned int ticket; 394 395 // get next free ticket 396 ticket = (unsigned int)hal_user_atomic_add( (int *)&mutex->free, 1 ); 397 398 #if PTHREAD_MUTEX_DEBUG 399 unsigned int cxy; 400 unsigned int lid; 401 get_core( &cxy , &lid ); 402 printf("\n[MUTEX DEBUG] %s : core[%x,%d] get ticket %d\n", 403 " / mutex = %x / current = %d / free = %d\n", 404 __FUNCTION__, cxy, lid, ticket, mutex, mutex->current, mutex->free ); 405 #endif 406 407 // poll the current index 408 while( 1 ) 409 { 410 if( mutex->current == ticket) break; 411 } 412 413 #if PTHREAD_MUTEX_DEBUG 414 printf("\n[MUTEX DEBUG] %s : core[%x,%d] get mutex %x / current = %d / free = %d\n", 415 __FUNCTION__, cxy, lid, mutex, mutex->current, mutex->free ); 416 #endif 417 418 return 0; 393 return hal_user_syscall( SYS_MUTEX, 394 (reg_t)mutex, 395 MUTEX_LOCK, 396 0, 0 ); 419 397 } 420 398 … … 422 400 int pthread_mutex_trylock( pthread_mutex_t * mutex ) 423 401 { 424 unsigned int ticket; 425 426 // get next free ticket 427 ticket = (unsigned int)hal_user_atomic_add( (int *)&mutex->free, 1 ); 428 429 #if PTHREAD_MUTEX_DEBUG 430 unsigned int cxy; 431 unsigned int lid; 432 get_core( &cxy, &lid ); 433 printf("\n[MUTEX DEBUG] %s : core[%x,%d] get ticket = %d" 434 " / mutex = %x / current = %d / free = %d\n", 435 __FUNCTION__, cxy, lid, ticket, mutex, mutex->current, mutex->free ); 436 #endif 437 438 // test ticket 439 if( ticket == mutex->current ) return 0; // success 440 else return -1; // failure 402 return hal_user_syscall( SYS_MUTEX, 403 (reg_t)mutex, 404 MUTEX_TRYLOCK, 405 0, 0 ); 441 406 } 442 407 … … 444 409 int pthread_mutex_unlock( pthread_mutex_t * mutex ) 445 410 { 446 hal_user_fence(); 447 448 mutex->current = mutex->current + 1; 449 450 #if PTHREAD_MUTEX_DEBUG 451 unsigned int cxy; 452 unsigned int lid; 453 get_core( &cxy , &lid ); 454 printf("\n[MUTEX_DEBUG] %s : core[%x,%d] releases mutex %x" 455 " / current = %d / free = %d\n", 456 __FUNCTION__, cxy, lid, mutex, mutex->current, mutex->free ); 457 #endif 458 459 return 0; 460 } 411 return hal_user_syscall( SYS_MUTEX, 412 (reg_t)mutex, 413 MUTEX_UNLOCK, 414 0, 0 ); 415 } 416 417 //////////////////////////////////////////////////////////////////////////////////////////// 418 // Condition variable 419 //////////////////////////////////////////////////////////////////////////////////////////// 420 421 /////////////////////////////////////////////// 422 int pthread_cond_init( pthread_cond_t * cond, 423 pthread_condattr_t * attr ) 424 { 425 if( attr ) 426 { 427 printf("[ERROR] in %s ; <attr> argument must be NULL\n", __FUNCTION__ ); 428 return -1; 429 } 430 431 return hal_user_syscall( SYS_CONDVAR, 432 (reg_t)cond, 433 CONDVAR_INIT, 434 0, 0 ); 435 } 436 437 ///////////////////////////////////////////////// 438 int pthread_cond_destroy( pthread_cond_t * cond ) 439 { 440 return hal_user_syscall( SYS_CONDVAR, 441 (reg_t)cond, 442 CONDVAR_DESTROY, 443 0, 0 ); 444 } 445 446 ////////////////////////////////////////////// 447 int pthread_cond_wait( pthread_cond_t * cond, 448 pthread_mutex_t * mutex ) 449 { 450 return hal_user_syscall( SYS_CONDVAR, 451 (reg_t)cond, 452 CONDVAR_WAIT, 453 (reg_t)mutex, 454 0 ); 455 } 456 457 //////////////////////////////////////////////// 458 int pthread_cond_signal( pthread_cond_t * cond ) 459 { 460 return hal_user_syscall( SYS_CONDVAR, 461 (reg_t)cond, 462 CONDVAR_SIGNAL, 463 0, 0 ); 464 } 465 466 /////////////////////////////////////////////////// 467 int pthread_cond_broadcast( pthread_cond_t * cond ) 468 { 469 return hal_user_syscall( SYS_CONDVAR, 470 (reg_t)cond, 471 CONDVAR_BROADCAST, 472 0, 0 ); 473 } 474 475 476 477 461 478 462 479 -
trunk/libs/libpthread/pthread.h
r477 r573 2 2 * pthread.h - User level <pthread> library definition. 3 3 * 4 * Author Alain Greiner (2016,2017 )4 * Author Alain Greiner (2016,2017,2018) 5 5 * 6 6 * Copyright (c) UPMC Sorbonne Universites … … 26 26 27 27 ////////////////////////////////////////////////////////////////////////////////////////////// 28 // POSIX Threads related functions (including barriers and mutexes) 28 // POSIX thread related functions 29 // 30 // This include the thread creation/destruction, as well as the synchronisations: 31 // barriers, mutexes, and condition variables. 29 32 ////////////////////////////////////////////////////////////////////////////////////////////// 30 33 … … 72 75 * pointer available to any successful pthread_join() with the terminating thread. 73 76 ********************************************************************************************* 74 * @ exit_vallue : [in] pointer to be returned to parent thread if th ead is attached.77 * @ exit_vallue : [in] pointer to be returned to parent thread if thread is attached. 75 78 * @ return 0 if success / return -1 if failure. 76 79 ********************************************************************************************/ … … 85 88 int pthread_yield( void ); 86 89 87 ////////////////////////////////////////////////////////////////////////////////////////////// 88 // POSIX Barriers related functions 90 91 ////////////////////////////////////////////////////////////////////////////////////////////// 92 // POSIX barrier related functions 89 93 // 90 94 // These functions are implemented in user space. Only the pthread_barrier_init() function 91 // uses sys calls to build the distributed quad-tree infrastructure.95 // uses system calls to build the distributed quad-tree infrastructure. 92 96 ////////////////////////////////////////////////////////////////////////////////////////////// 93 97 … … 100 104 * . The involved clusters form a mesh [x_size * y_size] 101 105 * . The lower left involved cluster is cluster(0,0) 102 * . The number of threads in acluster is the same in all clusters.106 * . The number of threads per cluster is the same in all clusters. 103 107 * 104 108 * Implementation note: … … 183 187 184 188 ////////////////////////////////////////////////////////////////////////////////////////////// 185 // POSIX Mutexes 186 // 187 // These functions are implemented in user space, and do not use syscalls. 188 // This implementation uses a ticket based policy to enforce fairness. 189 ////////////////////////////////////////////////////////////////////////////////////////////// 190 191 typedef struct pthread_mutex_s 192 { 193 volatile unsigned int current; /*! current index */ 194 volatile unsigned int free; /*! next free ticket index */ 195 } 196 pthread_mutex_t; 197 198 typedef struct pthread_mutexattr_s 199 { 200 int bloup; /*! unused */ 201 } 202 pthread_mutexattr_t; 189 // POSIX mutex related functions 190 ////////////////////////////////////////////////////////////////////////////////////////////// 203 191 204 192 /********************************************************************************************* … … 231 219 232 220 /********************************************************************************************* 221 * This function unlocks the mutex identified by the <mutex> argument. 222 ********************************************************************************************* 223 * @ mutex : pointer on mutex in user space. 224 * @ return 0 if success / return -1 if failure. 225 ********************************************************************************************/ 226 int pthread_mutex_unlock( pthread_mutex_t * mutex ); 227 228 /********************************************************************************************* 233 229 * This function tries to lock the mutex identified by the <mutex> argument, 234 230 * but don't block if the mutex is locked by another thread, including the current thread. … … 239 235 int pthread_mutex_trylock( pthread_mutex_t * mutex ); 240 236 241 /********************************************************************************************* 242 * This function unlocks the mutex identified by the <mutex> argument. 243 ********************************************************************************************* 244 * @ mutex : pointer on mutex in user space. 245 * @ return 0 if success / return -1 if failure. 246 ********************************************************************************************/ 247 int pthread_mutex_unlock( pthread_mutex_t * mutex ); 237 238 ////////////////////////////////////////////////////////////////////////////////////////////// 239 // POSIX condvar related functions 240 ////////////////////////////////////////////////////////////////////////////////////////////// 241 242 /********************************************************************************************* 243 * This function initializes a condition variable identified by the <cond> argument. 244 * WARNING: the <attr> argument is not supported and must be NULL. 245 ********************************************************************************************* 246 * @ cond : [in] pointer on condition in user space. 247 * @ attr : [in] pointer on condition attribute (must be NULL). 248 * @ return 0 if success / return -1 if failure. 249 ********************************************************************************************/ 250 int pthread_cond_init( pthread_cond_t * cond, 251 pthread_condattr_t * attr ); 252 253 /********************************************************************************************* 254 * This function atomically unlocks the <mutex> and blocks the calling thread on the 255 * condition specified by the <cond> argument. The thread unblocks only after another 256 * thread calls the pthread_cond_signal() or pthread_cond_broadcast() functions with the 257 * same condition variable. The mutex must be locked before calling this function, 258 * otherwise the behavior is undefined. Before the pthread_cond_wait() function returns 259 * to the calling function, it re-acquires the <mutex>. 260 ********************************************************************************************* 261 * @ cond : pointer on condition in user space. 262 * @ mutex : pointer on mutex in user space. 263 * @ return 0 if success / return -1 if failure. 264 ********************************************************************************************/ 265 int pthread_cond_wait( pthread_cond_t * cond, 266 pthread_mutex_t * mutex ); 267 268 /********************************************************************************************* 269 * This function unblocks one thread blocked on condition specified by the <cond> argument. 270 ********************************************************************************************* 271 * @ cond : pointer on condition in user space. 272 * @ return 0 if success / return -1 if failure. 273 ********************************************************************************************/ 274 int pthread_cond_signal( pthread_cond_t * cond ); 275 276 /********************************************************************************************* 277 * This function unblocks all threads blocked on condition specified by the <cond> argument. 278 ********************************************************************************************* 279 * @ cond : pointer on condition in user space. 280 * @ return 0 if success / return -1 if failure. 281 ********************************************************************************************/ 282 int pthread_cond_broadcast( pthread_cond_t * cond ); 283 284 /********************************************************************************************* 285 * This function delete the condition variable specified by the <cond> argument. 286 ********************************************************************************************* 287 * @ cond : pointer on condition in user space. 288 * @ return 0 if success / return -1 if failure. 289 ********************************************************************************************/ 290 int pthread_cond_destroy( pthread_cond_t * cond ); 291 248 292 249 293
Note: See TracChangeset
for help on using the changeset viewer.
