~ubuntu-branches/ubuntu/vivid/emscripten/vivid

1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.

2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.

3. This notice may not be removed or altered from any source distribution.

//#define __CELLOS_LV2__ 1

#define USE_SAMPLE_PROCESS 1

#ifdef USE_SAMPLE_PROCESS

#include "SpuSampleTaskProcess.h"

#include <stdio.h>

#ifdef __SPU__

void SampleThreadFunc(void* userPtr,void* lsMemory)

{

//do nothing

printf("hello world\n");

}

void* SamplelsMemoryFunc()

{

//don't create local store memory, just return 0

return 0;

}

#else

#include "btThreadSupportInterface.h"

//# include "SPUAssert.h"

#include <string.h>

extern "C" {

extern char SPU_SAMPLE_ELF_SYMBOL[];

}

SpuSampleTaskProcess::SpuSampleTaskProcess(btThreadSupportInterface* threadInterface, int maxNumOutstandingTasks)

:m_threadInterface(threadInterface),

m_maxNumOutstandingTasks(maxNumOutstandingTasks)

{

m_taskBusy.resize(m_maxNumOutstandingTasks);

m_spuSampleTaskDesc.resize(m_maxNumOutstandingTasks);

for (int i = 0; i < m_maxNumOutstandingTasks; i++)

{

m_taskBusy[i] = false;

}

m_numBusyTasks = 0;

m_currentTask = 0;

m_initialized = false;

m_threadInterface->startSPU();

}

SpuSampleTaskProcess::~SpuSampleTaskProcess()

{

m_threadInterface->stopSPU();

}

void SpuSampleTaskProcess::initialize()

{

#ifdef DEBUG_SPU_TASK_SCHEDULING

printf("SpuSampleTaskProcess::initialize()\n");

#endif //DEBUG_SPU_TASK_SCHEDULING

for (int i = 0; i < m_maxNumOutstandingTasks; i++)

{

m_taskBusy[i] = false;

100

}

101

m_numBusyTasks = 0;

102

m_currentTask = 0;

103

m_initialized = true;

104

105

}

106

107

108

void SpuSampleTaskProcess::issueTask(void* sampleMainMemPtr,int sampleValue,int sampleCommand)

109

{

110

111

#ifdef DEBUG_SPU_TASK_SCHEDULING

112

printf("SpuSampleTaskProcess::issueTask (m_currentTask= %d\)n", m_currentTask);

113

#endif //DEBUG_SPU_TASK_SCHEDULING

114

115

m_taskBusy[m_currentTask] = true;

116

m_numBusyTasks++;

117

118

SpuSampleTaskDesc& taskDesc = m_spuSampleTaskDesc[m_currentTask];

119

{

120

// send task description in event message

121

// no error checking here...

122

// but, currently, event queue can be no larger than NUM_WORKUNIT_TASKS.

123

124

taskDesc.m_mainMemoryPtr = reinterpret_cast<uint64_t>(sampleMainMemPtr);

125

taskDesc.m_sampleValue = sampleValue;

126

taskDesc.m_sampleCommand = sampleCommand;

127

128

//some bookkeeping to recognize finished tasks

129

taskDesc.m_taskId = m_currentTask;

130

}

131

132

133

m_threadInterface->sendRequest(1, (ppu_address_t) &taskDesc, m_currentTask);

134

135

// if all tasks busy, wait for spu event to clear the task.

136

137

if (m_numBusyTasks >= m_maxNumOutstandingTasks)

138

{

139

unsigned int taskId;

140

unsigned int outputSize;

141

142

for (int i=0;i<m_maxNumOutstandingTasks;i++)

143

{

144

if (m_taskBusy[i])

145

{

146

taskId = i;

147

break;

148

}

149

}

150

m_threadInterface->waitForResponse(&taskId, &outputSize);

151

152

//printf("PPU: after issue, received event: %u %d\n", taskId, outputSize);

153

154

postProcess(taskId, outputSize);

155

156

m_taskBusy[taskId] = false;

157

158

m_numBusyTasks--;

159

}

160

161

// find new task buffer

162

for (int i = 0; i < m_maxNumOutstandingTasks; i++)

163

{

164

if (!m_taskBusy[i])

165

{

166

m_currentTask = i;

167

break;

168

}

169

}

170

}

171

172

173

///Optional PPU-size post processing for each task

174

void SpuSampleTaskProcess::postProcess(int taskId, int outputSize)

175

{

176

177

}

178

179

180

void SpuSampleTaskProcess::flush()

181

{

182

#ifdef DEBUG_SPU_TASK_SCHEDULING

183

printf("\nSpuCollisionTaskProcess::flush()\n");

184

#endif //DEBUG_SPU_TASK_SCHEDULING

185

186

187

// all tasks are issued, wait for all tasks to be complete

188

while(m_numBusyTasks > 0)

189

{

190

// Consolidating SPU code

191

unsigned int taskId;

192

unsigned int outputSize;

193

194

for (int i=0;i<m_maxNumOutstandingTasks;i++)

195

{

196

if (m_taskBusy[i])

197

{

198

taskId = i;

199

break;

200

}

201

}

202

{

203

204

m_threadInterface->waitForResponse(&taskId, &outputSize);

205

}

206

207

//printf("PPU: flushing, received event: %u %d\n", taskId, outputSize);

208

209

postProcess(taskId, outputSize);

210

211

m_taskBusy[taskId] = false;

212

213

m_numBusyTasks--;

214

}

215

216

217

}

218

219

#endif

220

221

222

#endif //USE_SAMPLE_PROCESS

Older »