/[svn]/linuxsampler/trunk/src/common/Thread.h
ViewVC logotype

Diff of /linuxsampler/trunk/src/common/Thread.h

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1480 by schoenebeck, Sun Oct 14 22:00:17 2007 UTC revision 1481 by senoner, Wed Nov 14 23:42:15 2007 UTC
# Line 24  Line 24 
24  #ifndef __LS_THREAD_H__  #ifndef __LS_THREAD_H__
25  #define __LS_THREAD_H__  #define __LS_THREAD_H__
26    
27    //FIXME: jthis is a temorary solution because of problems with condition variables we use a polling lock in SignalStartThread()
28    #define WIN32_SIGNALSTARTTHREAD_WORKAROUND 1
29    
30  #include <iostream>  #include <iostream>
31  #include <stdio.h>  #include <stdio.h>
32  #include <stdlib.h>  #include <stdlib.h>
33    
34    #if defined(WIN32)
35    #include <windows.h>
36    #else
37  #include <sched.h>  #include <sched.h>
38  #include <sys/mman.h>  #include <sys/mman.h>
39  #include <memory.h>  #include <memory.h>
40  #include <pthread.h>  #include <pthread.h>
41    #endif
42  #include <errno.h>  #include <errno.h>
43    
44  #include "Condition.h"  #include "Condition.h"
# Line 52  class Thread { Line 60  class Thread {
60          virtual void EnableDestructor();      //FIXME: should be private          virtual void EnableDestructor();      //FIXME: should be private
61          virtual int  Destructor();            //FIXME: should be private          virtual int  Destructor();            //FIXME: should be private
62          virtual int  Main() = 0; ///< This method needs to be implemented by the descendant and is the entry point for the new thread. FIXME: should be protected          virtual int  Main() = 0; ///< This method needs to be implemented by the descendant and is the entry point for the new thread. FIXME: should be protected
63                    
64        /**
65         * allocates an aligned block of memory
66         * allocated memory blocks need to be freed using freeAlignedMem()
67         * @param boundary - the alignement boundary, usually a power of 2, eg 4 but it can be an arbitrary number between 1 and 128
68         *  @param size - size in bytes to be allocated  
69        *   @return pointer to the allocated memory block
70         */        
71    
72            static void* allocAlignedMem(size_t boundary, size_t size) {
73                unsigned char *ptr = (unsigned char *)malloc(size+boundary);
74                size_t offset = boundary - ((size_t)ptr % boundary);
75                ptr[offset-1] = (unsigned char)offset;
76                return (ptr + offset);
77            }
78    
79        /**
80         * frees s a aligned block of memory allocated with  allocAlignedMem()
81         * @param ptr - pointer to the memory block
82                     */                    
83            static void freeAlignedMem(void *ptr) {
84                unsigned char *p = (unsigned char *)ptr;
85                p -= p[-1];
86                free(p);
87            }
88                    
89            /**
90                         * locks a region of memory in physical RAM
91                         * @param addr - address of the memory block
92                         * @param size- size of the memory block
93                         * @return true if the locking succeded, otherwise false
94                         */
95            static bool lockMemory(void *addr, size_t size) {
96                #if defined(WIN32)
97                return VirtualLock(addr, size);
98                #else
99                return !mlock(addr, size);
100                #endif
101            }
102                    
103            /**
104            * unlocks a region of memory in physical RAM
105            * @param addr - address of the memory block
106            * @param size- size of the memory block
107            * @return true if the unlocking succeded, otherwise false
108            */
109            static bool unlockMemory(void *addr, size_t size) {
110                #if defined(WIN32)
111                return VirtualUnlock(addr, size);
112                #else
113                return !munlock(addr, size);
114                #endif
115            }
116                    
117                    
118      private:      private:
119        #if defined(WIN32)
120            HANDLE hThread;
121            DWORD lpThreadId;
122            #if defined(WIN32_SIGNALSTARTTHREAD_WORKAROUND)
123            bool win32isRunning;
124            #endif
125        #else
126          pthread_attr_t  __thread_attr;          pthread_attr_t  __thread_attr;
127          pthread_t       __thread_id;          pthread_t       __thread_id;
128          pthread_key_t   __thread_destructor_key;          pthread_key_t   __thread_destructor_key;
129        #endif
130          Condition       RunningCondition;          Condition       RunningCondition;
131          int             PriorityMax;          int             PriorityMax;
132          int             PriorityDelta;          int             PriorityDelta;
Legend:
Removed from v.1480  
changed lines
  Added in v.1481
  ViewVC Help
Powered by ViewVC