Kludge Tracker: Gnuradio - v3.4.0-101-g7e2b45b

Kludge Summary of gnuradio/gcell

All Directories within gnuradio/gcell

• gnuradio/gcell/apps (1)
• gnuradio/gcell/include (1)
• gnuradio/gcell/include/gcell (1)
• gnuradio/gcell/lib (22)
• gnuradio/gcell/lib/general (1)
• gnuradio/gcell/lib/general/spu (1)
• gnuradio/gcell/lib/runtime (15)
• gnuradio/gcell/lib/runtime/spu (1)
• gnuradio/gcell/lib/wrapper (6)
• gnuradio/gcell/lib/wrapper/spu (4)

All Files within gnuradio/gcell

• gnuradio/gcell/apps/gen_script.py (1)
• gnuradio/gcell/include/gcell/gc_jd_queue_data.h (1)
• gnuradio/gcell/lib/general/spu/qa_memset.c (1)
• gnuradio/gcell/lib/runtime/gc_jd_stack.c (1)
• gnuradio/gcell/lib/runtime/gc_job_manager_impl.cc (10)
• gnuradio/gcell/lib/runtime/qa_jd_queue.cc (2)
• gnuradio/gcell/lib/runtime/qa_jd_stack.cc (1)
• gnuradio/gcell/lib/runtime/spu/gc_main.c (1)
• gnuradio/gcell/lib/wrapper/qa_gcp_fft_1d_r2.cc (2)
• gnuradio/gcell/lib/wrapper/spu/gcs_fft_1d_r2.c (4)

Kludge Snippets in gnuradio/gcell

gnuradio/gcell/apps/gen_script.py

56            if len(args) != 0:
57                parser.print_help()
58                sys.exit(1)
59        
60            #FIXME to use git now
61            svn_rev = get_svn_rev()
62        
63            os.environ['TZ'] = 'PST8PDT'        # always pacific
64            time.tzset()
				

gnuradio/gcell/include/gcell/gc_jd_queue_data.h

33         * This is the main data structure shared between PPEs and SPEs.
34         * It is used to enqueue work for SPEs.  SPEs or PPEs may enqueue
35         * work.  SPE's dequeue from here.
36         *
37         * FIXME make it lock free ;)  For now, use a spin lock.
38         *
39         * (Fills a single cache line)
40         */
41        typedef struct gc_jd_queue
				

gnuradio/gcell/lib/general/spu/qa_memset.c

30        #define	MAX_OFFSET    32
31        #define	ALIGNMENT     16
32        #define	K	      0xA5
33        
34        // FIXME should be passed at gcell init time
35        //static const int TIMEBASE = 79800000; // ps3
36        static const int TIMEBASE = 26666666; // qs21
37        
38        typedef void* (*memset_fptr)(void *s, int val, size_t n);
				

gnuradio/gcell/lib/runtime/gc_jd_stack.c

23        #include <gcell/memory_barrier.h>
24        
25        /*
26         * begin extract from ppu_intrinics.h
27         * FIXME handle this a different way
28         */
29        
30        #if !defined(__PPU__) && !defined(__ppc__) && !defined(__ppc64__)
31            && !defined(__GNUC__)
				

gnuradio/gcell/lib/runtime/gc_job_manager_impl.cc — 1

63        
64        static const unsigned int DEFAULT_MAX_JOBS = 128;
65        static const unsigned int DEFAULT_MAX_CLIENT_THREADS = 64;
66        
67        // FIXME this really depends on the SPU code...
68        static const unsigned int MAX_TOTAL_INDIRECT_LENGTH = 16 * 1024;
69        
70        
71        static bool          s_key_initialized = false;
				

gnuradio/gcell/lib/runtime/gc_job_manager_impl.cc — 2

179        	// If we're gang scheduling we'll never get scheduled if we
180        	// ask for more than are available.
181        	throw std::out_of_range("gang_scheduling: not enough spes available");
182              }
183              else {	// FIXME clamp to usable.  problem on PS3 when overcommited
184        	fprintf(stderr, "gc_job_manager: clamping nspes to %d\n", nusable_spes);
185        	d_options.nspes = nusable_spes;
186              }
187            }
				

gnuradio/gcell/lib/runtime/gc_job_manager_impl.cc — 3

246        		   | SPE_CFG_SIGNOTIFY1_OR
247        		   | SPE_CFG_SIGNOTIFY2_OR);
248          
249          for (unsigned int i = 0; i < d_options.nspes; i++){
250            // FIXME affinity stuff goes here
251            d_worker[i].spe_ctx = spe_context_create(spe_flags, d_gang.get());;
252            if (d_worker[i].spe_ctx == 0){
253              perror("spe_context_create");
254              throw std::runtime_error("spe_context_create");
				

gnuradio/gcell/lib/runtime/gc_job_manager_impl.cc — 4

644        
645              if (mode == GC_WAIT_ALL && ndone == njobs)
646        	break;
647        
648              // FIXME what happens when somebody calls shutdown?
649        
650              cti->d_cond.wait(l);	// wait for event handler to wake us up
651            }
652        
				

gnuradio/gcell/lib/runtime/gc_job_manager_impl.cc — 5

736          pthread_attr_t attr;
737          pthread_attr_init(&attr);
738          pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
739        
740          // FIXME save sigprocmask
741          // FIXME set sigprocmask
742        
743          int r = pthread_create(thread, &attr, start_routine, arg);
744            
				

gnuradio/gcell/lib/runtime/gc_job_manager_impl.cc — 6

737          pthread_attr_init(&attr);
738          pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
739        
740          // FIXME save sigprocmask
741          // FIXME set sigprocmask
742        
743          int r = pthread_create(thread, &attr, start_routine, arg);
744            
745          // FIXME restore sigprocmask
				

gnuradio/gcell/lib/runtime/gc_job_manager_impl.cc — 7

741          // FIXME set sigprocmask
742        
743          int r = pthread_create(thread, &attr, start_routine, arg);
744            
745          // FIXME restore sigprocmask
746        
747          if (r != 0){
748            pthread_create_failure_msg(r, msg);
749            return false;
				

gnuradio/gcell/lib/runtime/gc_job_manager_impl.cc — 8

819          }
820        
821          if (!ok){
822            //
823            // FIXME Clean up the mess.  Need to terminate event handler and all workers.
824            //
825            // this should cause the workers to exit, unless they're seriously broken
826            send_all_spes(MK_MBOX_MSG(OP_EXIT, 0));
827        
				

gnuradio/gcell/lib/runtime/gc_job_manager_impl.cc — 9

953            if (cti != last_cti){	// new client?
954        
955              // yes.  signal old client, unlock old, lock new
956        
957              // FIXME we could distinguish between CT_WAIT_ALL & CT_WAIT_ANY
958        
959              if (last_cti->d_state == CT_WAIT_ANY || last_cti->d_state == CT_WAIT_ALL)
960        	last_cti->d_cond.notify_one();	// wake client thread up
961        
				

gnuradio/gcell/lib/runtime/gc_job_manager_impl.cc — 10

1135            int nevents = spe_event_wait(d_spe_event_handler.ptr,
1136        				 events, MAX_EVENTS, TIMEOUT);
1137            if (nevents < 0){
1138              perror("spe_wait_event");
1139              // FIXME bail?
1140            }
1141            for (int i = 0; i < nevents; i++){
1142              handle_event(&events[i]);
1143            }
				

gnuradio/gcell/lib/runtime/qa_jd_queue.cc — 1

64        
65          CPPUNIT_ASSERT(gc_jd_queue_dequeue(&queue) == 0);
66        }
67        
68        // FIXME multithreaded (running on PPE)
69        void
70        qa_jd_queue::t2()
71        {
72        }
				

gnuradio/gcell/lib/runtime/qa_jd_queue.cc — 2

70        qa_jd_queue::t2()
71        {
72        }
73        
74        // FIXME multithreaded (running on PPE & SPE)
75        void
76        qa_jd_queue::t3()
77        {
78        }
				

gnuradio/gcell/lib/runtime/qa_jd_stack.cc

59        
60          CPPUNIT_ASSERT(gc_jd_stack_pop(&stack) == 0);
61        }
62        
63        // FIXME multithreaded (running on PPE)
64        void
65        qa_jd_stack::t2()
66        {
67        }
				

gnuradio/gcell/lib/runtime/spu/gc_main.c

375        		   && dma_len <= (eaa->arg[i].get_size + offset + CACHE_LINE_SIZE - 1));
376        	  }
377        
378        	  // add to dma get list 
379        	  // FIXME (someday) the dma list is where the JS_BAD_EAH limitation comes from
380        
381        	  while (dma_len != 0){
382        	    int n = MIN(dma_len, MFC_MAX_DMA_SIZE);
383        	    dma_get_list[gli].size = n;
				

gnuradio/gcell/lib/wrapper/qa_gcp_fft_1d_r2.cc — 1

101        
102        void
103        qa_gcp_fft_1d_r2::t3()
104        {
105          // FIXME Test fwd and inv with windowing option
106        }
107        
108        void
109        qa_gcp_fft_1d_r2::t4()
				

gnuradio/gcell/lib/wrapper/qa_gcp_fft_1d_r2.cc — 2

107        
108        void
109        qa_gcp_fft_1d_r2::t4()
110        {
111          // FIXME Test fwd and inv with shift option
112        }
113        
114        static inline float
115        abs_diff(std::complex<float> x, std::complex<float> y)
				

gnuradio/gcell/lib/wrapper/spu/gcs_fft_1d_r2.c — 1

48          int log2_fft_length = input->arg[0].u32;
49          int shift = input->arg[1].u32;	// non-zero if we should apply fftshift
50        
51          if (eaa->arg[3].get_size){	// apply window
52            // FIXME pointwise multiply in *= window
53            assert(0);
54          }
55        
56          fft_1d_r2(out, in, twiddle, log2_fft_length);
				

gnuradio/gcell/lib/wrapper/spu/gcs_fft_1d_r2.c — 2

55        
56          fft_1d_r2(out, in, twiddle, log2_fft_length);
57        
58          if (shift){
59            // FIXME apply "fftshift" to output data in-place
60            assert(0);
61          }
62        }
63        
				

gnuradio/gcell/lib/wrapper/spu/gcs_fft_1d_r2.c — 3

76          int log2_fft_length = input->arg[0].u32;
77          int shift = input->arg[1].u32;	// non-zero if we should apply fftshift
78        
79          if (eaa->arg[3].get_size){	// apply window
80            // FIXME pointwise multiply in *= window
81            assert(0);
82          }
83        
84          if (shift){
				

gnuradio/gcell/lib/wrapper/spu/gcs_fft_1d_r2.c — 4

81            assert(0);
82          }
83        
84          if (shift){
85            // FIXME apply "fftshift" to input data in-place
86            assert(0);
87          }
88        
89          conjugate_vector(in, 1 << (log2_fft_length - 1));