cpu_ref/rsCpuScriptGroup2.cpp - platform/frameworks/rs - Git at Google

 #include "rsCpuScriptGroup2.h"

 #include <dlfcn.h>

 #include <string>
 #include <vector>

 #ifndef RS_COMPATIBILITY_LIB
 #include "bcc/Config/Config.h"
 #include <sys/wait.h>
 #endif

 #include "cpu_ref/rsCpuCore.h"
 #include "rsClosure.h"
 #include "rsContext.h"
 #include "rsCpuCore.h"
 #include "rsCpuScript.h"
 #include "rsScript.h"
 #include "rsScriptGroup2.h"
 #include "rsScriptIntrinsic.h"

 using std::string;
 using std::vector;

 namespace android {
 namespace renderscript {

 namespace {

 const size_t DefaultKernelArgCount = 2;

 void groupRoot(const RsExpandKernelParams *kparams, uint32_t xstart,
                uint32_t xend, uint32_t outstep) {
   const list<CPUClosure*>& closures = *(list<CPUClosure*>*)kparams->usr;
   RsExpandKernelParams *mutable_kparams = (RsExpandKernelParams *)kparams;
   const void **oldIns  = kparams->ins;
   uint32_t *oldStrides = kparams->inEStrides;

   std::vector<const void*> ins(DefaultKernelArgCount);
   std::vector<uint32_t> strides(DefaultKernelArgCount);

   for (CPUClosure* cpuClosure : closures) {
     const Closure* closure = cpuClosure->mClosure;

     auto in_iter = ins.begin();
     auto stride_iter = strides.begin();

     for (const auto& arg : closure->mArgs) {
       const Allocation* a = (const Allocation*)arg;
       const uint32_t eStride = a->mHal.state.elementSizeBytes;
       const uint8_t* ptr = (uint8_t*)(a->mHal.drvState.lod[0].mallocPtr) +
           eStride * xstart;
       if (kparams->dimY > 1) {
         ptr += a->mHal.drvState.lod[0].stride * kparams->y;
       }
       *in_iter++ = ptr;
       *stride_iter++ = eStride;
     }

     mutable_kparams->ins = &ins[0];
     mutable_kparams->inEStrides = &strides[0];

     const Allocation* out = closure->mReturnValue;
     const uint32_t ostep = out->mHal.state.elementSizeBytes;
     const uint8_t* ptr = (uint8_t *)(out->mHal.drvState.lod[0].mallocPtr) +
            ostep * xstart;
     if (kparams->dimY > 1) {
       ptr += out->mHal.drvState.lod[0].stride * kparams->y;
     }

     mutable_kparams->out = (void*)ptr;

     mutable_kparams->usr = cpuClosure->mUsrPtr;

     cpuClosure->mFunc(kparams, xstart, xend, ostep);
   }

   mutable_kparams->ins        = oldIns;
   mutable_kparams->inEStrides = oldStrides;
   mutable_kparams->usr        = &closures;
 }

 }  // namespace

 Batch::~Batch() {
   for (CPUClosure* c : mClosures) {
     delete c;
   }
   if (mScriptObj) {
     dlclose(mScriptObj);
   }
 }

 bool Batch::conflict(CPUClosure* closure) const {
   if (mClosures.empty()) {
     return false;
   }

   if (closure->mClosure->mKernelID.get() == nullptr ||
       mClosures.front()->mClosure->mKernelID.get() == nullptr) {
     // An invoke should be in a batch by itself, so it conflicts with any other
     // closure.
     return true;
   }

   for (const auto &p : closure->mClosure->mGlobalDeps) {
     const Closure* dep = p.first;
     for (CPUClosure* c : mClosures) {
       if (c->mClosure == dep) {
         ALOGV("ScriptGroup2: closure %p conflicting with closure %p via its global", closure, dep);
         return true;
       }
     }
   }
   for (const auto &p : closure->mClosure->mArgDeps) {
     const Closure* dep = p.first;
     for (CPUClosure* c : mClosures) {
       if (c->mClosure == dep) {
         for (const auto &p1 : *p.second) {
           if (p1.second->get() != nullptr) {
             ALOGV("ScriptGroup2: closure %p conflicting with closure %p via its arg", closure, dep);
             return true;
           }
         }
       }
     }
   }
   return false;
 }

 CpuScriptGroup2Impl::CpuScriptGroup2Impl(RsdCpuReferenceImpl *cpuRefImpl,
                                          const ScriptGroupBase *sg) :
     mCpuRefImpl(cpuRefImpl), mGroup((const ScriptGroup2*)(sg)) {
   Batch* batch = new Batch(this);
   for (Closure* closure: mGroup->mClosures) {
     const ScriptKernelID* kernelID = closure->mKernelID.get();
     RsdCpuScriptImpl* si =
         (RsdCpuScriptImpl *)mCpuRefImpl->lookupScript(kernelID->mScript);

     MTLaunchStruct mtls;
     si->forEachKernelSetup(kernelID->mSlot, &mtls);
     // TODO: Is mtls.fep.usrLen ever used?
     CPUClosure* cc = new CPUClosure(closure, si, (ExpandFuncTy)mtls.kernel,
                                     mtls.fep.usr, mtls.fep.usrLen);
     if (batch->conflict(cc)) {
       mBatches.push_back(batch);
       batch = new Batch(this);
     }

     batch->mClosures.push_back(cc);
   }

   mBatches.push_back(batch);

 #ifndef RS_COMPATIBILITY_LIB
   for (Batch* batch : mBatches) {
     batch->tryToCreateFusedKernel(mGroup->mCacheDir.c_str());
   }
 #endif
 }

 CpuScriptGroup2Impl::~CpuScriptGroup2Impl() {
   for (Batch* batch : mBatches) {
     delete batch;
   }
 }

 namespace {

 #ifndef RS_COMPATIBILITY_LIB

 string getFileName(string path) {
   unsigned found = path.find_last_of("/\\");
   return path.substr(found + 1);
 }

 void setupCompileArguments(
     const vector<string>& inputs, const vector<int>& kernels,
     const string& output_dir, const string& output_filename,
     const string& rsLib, vector<const char*>* args) {
   args->push_back(RsdCpuScriptImpl::BCC_EXE_PATH);
   args->push_back("-fPIC");
   args->push_back("-embedRSInfo");
   args->push_back("-mtriple");
   args->push_back(DEFAULT_TARGET_TRIPLE_STRING);
   args->push_back("-bclib");
   args->push_back(rsLib.c_str());
   for (const string& input : inputs) {
     args->push_back(input.c_str());
   }
   for (int kernel : kernels) {
     args->push_back("-k");
     string strKernel = std::to_string(kernel);
     args->push_back(strKernel.c_str());
   }
   args->push_back("-output_path");
   args->push_back(output_dir.c_str());
   args->push_back("-o");
   args->push_back(output_filename.c_str());
   args->push_back(nullptr);
 }

 string convertListToString(int n, const char* const* strs) {
   string ret;
   ret.append(strs[0]);
   for (int i = 1; i < n; i++) {
     ret.append(" ");
     ret.append(strs[i]);
   }
   return ret;
 }

 bool fuseAndCompile(const char** arguments,
                     const string& commandLine) {
   const pid_t pid = fork();

   if (pid == -1) {
     ALOGE("Couldn't fork for bcc execution");
     return false;
   }

   if (pid == 0) {
     // Child process
     ALOGV("Invoking BCC with: %s", commandLine.c_str());
     execv(RsdCpuScriptImpl::BCC_EXE_PATH, (char* const*)arguments);

     ALOGE("execv() failed: %s", strerror(errno));
     abort();
     return false;
   }

   // Parent process
   int status = 0;
   const pid_t w = waitpid(pid, &status, 0);
   if (w == -1) {
     return false;
   }

   if (!WIFEXITED(status) || WEXITSTATUS(status) != 0 ) {
     ALOGE("bcc terminated unexpectedly");
     return false;
   }

   return true;
 }
 #endif

 }  // anonymous namespace

 void Batch::tryToCreateFusedKernel(const char *cacheDir) {
 #ifndef RS_COMPATIBILITY_LIB
   if (mClosures.size() < 2) {
     ALOGV("Compiler kernel fusion skipped due to only one or zero kernel in"
           " a script group batch.");
     return;
   }

   //===--------------------------------------------------------------------===//
   // Fuse the input kernels and generate native code in an object file
   //===--------------------------------------------------------------------===//

   std::vector<string> inputFiles;
   std::vector<int> slots;

   for (CPUClosure* cpuClosure : mClosures) {
     const Closure* closure = cpuClosure->mClosure;
     const ScriptKernelID* kernelID = closure->mKernelID.get();
     const Script* script = kernelID->mScript;

     if (script->isIntrinsic()) {
       return;
     }

     const RsdCpuScriptImpl *cpuScript =
         (const RsdCpuScriptImpl*)script->mHal.drv;

     const string& bitcodeFilename = cpuScript->getBitcodeFilePath();

     inputFiles.push_back(bitcodeFilename);
     slots.push_back(kernelID->mSlot);
   }

   string outputPath(tempnam(cacheDir, "fused"));
   string outputFileName = getFileName(outputPath);
   string objFilePath(outputPath);
   objFilePath.append(".o");
   string rsLibPath(SYSLIBPATH"/libclcore.bc");
   vector<const char*> arguments;
   setupCompileArguments(inputFiles, slots, cacheDir, outputFileName, rsLibPath,
                         &arguments);
   string commandLine =
       convertListToString(arguments.size() - 1, arguments.data());

   if (!fuseAndCompile(arguments.data(), commandLine)) {
     return;
   }

   //===--------------------------------------------------------------------===//
   // Create and load the shared lib
   //===--------------------------------------------------------------------===//

   const char* resName = outputFileName.c_str();

   if (!SharedLibraryUtils::createSharedLibrary(cacheDir, resName)) {
     ALOGE("Failed to link object file '%s'", resName);
     return;
   }

   void* mSharedObj = SharedLibraryUtils::loadSharedLibrary(cacheDir, resName);
   if (mSharedObj == nullptr) {
     ALOGE("Unable to load '%s'", resName);
     return;
   }

   mExecutable = ScriptExecutable::createFromSharedObject(
       nullptr,  // RS context. Unused.
       mSharedObj);

 #endif  // RS_COMPATIBILITY_LIB
 }

 void CpuScriptGroup2Impl::execute() {
   for (auto batch : mBatches) {
     batch->setGlobalsForBatch();
     batch->run();
   }
 }

 void Batch::setGlobalsForBatch() {
   for (CPUClosure* cpuClosure : mClosures) {
     const Closure* closure = cpuClosure->mClosure;
     const ScriptKernelID* kernelID = closure->mKernelID.get();
     Script* s = kernelID->mScript;
     for (const auto& p : closure->mGlobals) {
       const void* value = p.second.first;
       int size = p.second.second;
       // We use -1 size to indicate an ObjectBase rather than a primitive type
       if (size < 0) {
         s->setVarObj(p.first->mSlot, (ObjectBase*)value);
       } else {
         s->setVar(p.first->mSlot, (const void*)&value, size);
       }
     }
   }
 }

 void Batch::run() {
   if (mExecutable != nullptr) {
     MTLaunchStruct mtls;
     const CPUClosure* firstCpuClosure = mClosures.front();
     const CPUClosure* lastCpuClosure = mClosures.back();

     firstCpuClosure->mSi->forEachMtlsSetup(
         (const Allocation**)&firstCpuClosure->mClosure->mArgs[0],
         firstCpuClosure->mClosure->mArgs.size(),
         lastCpuClosure->mClosure->mReturnValue,
         nullptr, 0, nullptr, &mtls);

     mtls.script = nullptr;
     mtls.fep.usr = nullptr;
     mtls.kernel = mExecutable->getForEachFunction(0);

     mGroup->getCpuRefImpl()->launchThreads(
         (const Allocation**)&firstCpuClosure->mClosure->mArgs[0],
         firstCpuClosure->mClosure->mArgs.size(),
         lastCpuClosure->mClosure->mReturnValue,
         nullptr, &mtls);

     return;
   }

   for (CPUClosure* cpuClosure : mClosures) {
     const Closure* closure = cpuClosure->mClosure;
     const ScriptKernelID* kernelID = closure->mKernelID.get();
     cpuClosure->mSi->preLaunch(kernelID->mSlot,
                                (const Allocation**)&closure->mArgs[0],
                                closure->mArgs.size(), closure->mReturnValue,
                                cpuClosure->mUsrPtr, cpuClosure->mUsrSize,
                                nullptr);
   }

   const CPUClosure* cpuClosure = mClosures.front();
   const Closure* closure = cpuClosure->mClosure;
   MTLaunchStruct mtls;

   if (cpuClosure->mSi->forEachMtlsSetup((const Allocation**)&closure->mArgs[0],
                                         closure->mArgs.size(),
                                         closure->mReturnValue,
                                         nullptr, 0, nullptr, &mtls)) {

       mtls.script = nullptr;
       mtls.kernel = (void (*)())&groupRoot;
       mtls.fep.usr = &mClosures;

       mGroup->getCpuRefImpl()->launchThreads(nullptr, 0, nullptr, nullptr, &mtls);
   }

   for (CPUClosure* cpuClosure : mClosures) {
     const Closure* closure = cpuClosure->mClosure;
     const ScriptKernelID* kernelID = closure->mKernelID.get();
     cpuClosure->mSi->postLaunch(kernelID->mSlot,
                                 (const Allocation**)&closure->mArgs[0],
                                 closure->mArgs.size(), closure->mReturnValue,
                                 nullptr, 0, nullptr);
   }
 }

 }  // namespace renderscript
 }  // namespace android
	#include "rsCpuScriptGroup2.h"

	#include <dlfcn.h>

	#include <string>
	#include <vector>

	#ifndef RS_COMPATIBILITY_LIB
	#include "bcc/Config/Config.h"
	#include <sys/wait.h>
	#endif

	#include "cpu_ref/rsCpuCore.h"
	#include "rsClosure.h"
	#include "rsContext.h"
	#include "rsCpuCore.h"
	#include "rsCpuScript.h"
	#include "rsScript.h"
	#include "rsScriptGroup2.h"
	#include "rsScriptIntrinsic.h"

	using std::string;
	using std::vector;

	namespace android {
	namespace renderscript {

	namespace {

	const size_t DefaultKernelArgCount = 2;

	void groupRoot(const RsExpandKernelParams *kparams, uint32_t xstart,
	uint32_t xend, uint32_t outstep) {
	const list<CPUClosure>& closures = (list<CPUClosure>)kparams->usr;
	RsExpandKernelParams mutable_kparams = (RsExpandKernelParams )kparams;
	const void **oldIns = kparams->ins;
	uint32_t *oldStrides = kparams->inEStrides;

	std::vector<const void*> ins(DefaultKernelArgCount);
	std::vector<uint32_t> strides(DefaultKernelArgCount);

	for (CPUClosure* cpuClosure : closures) {
	const Closure* closure = cpuClosure->mClosure;

	auto in_iter = ins.begin();
	auto stride_iter = strides.begin();

	for (const auto& arg : closure->mArgs) {
	const Allocation* a = (const Allocation*)arg;
	const uint32_t eStride = a->mHal.state.elementSizeBytes;
	const uint8_t* ptr = (uint8_t*)(a->mHal.drvState.lod[0].mallocPtr) +
	eStride * xstart;
	if (kparams->dimY > 1) {
	ptr += a->mHal.drvState.lod[0].stride * kparams->y;
	}
	*in_iter++ = ptr;
	*stride_iter++ = eStride;
	}

	mutable_kparams->ins = &ins[0];
	mutable_kparams->inEStrides = &strides[0];

	const Allocation* out = closure->mReturnValue;
	const uint32_t ostep = out->mHal.state.elementSizeBytes;
	const uint8_t* ptr = (uint8_t *)(out->mHal.drvState.lod[0].mallocPtr) +
	ostep * xstart;
	if (kparams->dimY > 1) {
	ptr += out->mHal.drvState.lod[0].stride * kparams->y;
	}

	mutable_kparams->out = (void*)ptr;

	mutable_kparams->usr = cpuClosure->mUsrPtr;

	cpuClosure->mFunc(kparams, xstart, xend, ostep);
	}

	mutable_kparams->ins = oldIns;
	mutable_kparams->inEStrides = oldStrides;
	mutable_kparams->usr = &closures;
	}

	} // namespace

	Batch::~Batch() {
	for (CPUClosure* c : mClosures) {
	delete c;
	}
	if (mScriptObj) {
	dlclose(mScriptObj);
	}
	}

	bool Batch::conflict(CPUClosure* closure) const {
	if (mClosures.empty()) {
	return false;
	}

	if (closure->mClosure->mKernelID.get() == nullptr \|\|
	mClosures.front()->mClosure->mKernelID.get() == nullptr) {
	// An invoke should be in a batch by itself, so it conflicts with any other
	// closure.
	return true;
	}

	for (const auto &p : closure->mClosure->mGlobalDeps) {
	const Closure* dep = p.first;
	for (CPUClosure* c : mClosures) {
	if (c->mClosure == dep) {
	ALOGV("ScriptGroup2: closure %p conflicting with closure %p via its global", closure, dep);
	return true;
	}
	}
	}
	for (const auto &p : closure->mClosure->mArgDeps) {
	const Closure* dep = p.first;
	for (CPUClosure* c : mClosures) {
	if (c->mClosure == dep) {
	for (const auto &p1 : *p.second) {
	if (p1.second->get() != nullptr) {
	ALOGV("ScriptGroup2: closure %p conflicting with closure %p via its arg", closure, dep);
	return true;
	}
	}
	}
	}
	}
	return false;
	}

	CpuScriptGroup2Impl::CpuScriptGroup2Impl(RsdCpuReferenceImpl *cpuRefImpl,
	const ScriptGroupBase *sg) :
	mCpuRefImpl(cpuRefImpl), mGroup((const ScriptGroup2*)(sg)) {
	Batch* batch = new Batch(this);
	for (Closure* closure: mGroup->mClosures) {
	const ScriptKernelID* kernelID = closure->mKernelID.get();
	RsdCpuScriptImpl* si =
	(RsdCpuScriptImpl *)mCpuRefImpl->lookupScript(kernelID->mScript);

	MTLaunchStruct mtls;
	si->forEachKernelSetup(kernelID->mSlot, &mtls);
	// TODO: Is mtls.fep.usrLen ever used?
	CPUClosure* cc = new CPUClosure(closure, si, (ExpandFuncTy)mtls.kernel,
	mtls.fep.usr, mtls.fep.usrLen);
	if (batch->conflict(cc)) {
	mBatches.push_back(batch);
	batch = new Batch(this);
	}

	batch->mClosures.push_back(cc);
	}

	mBatches.push_back(batch);

	#ifndef RS_COMPATIBILITY_LIB
	for (Batch* batch : mBatches) {
	batch->tryToCreateFusedKernel(mGroup->mCacheDir.c_str());
	}
	#endif
	}

	CpuScriptGroup2Impl::~CpuScriptGroup2Impl() {
	for (Batch* batch : mBatches) {
	delete batch;
	}
	}

	namespace {

	#ifndef RS_COMPATIBILITY_LIB

	string getFileName(string path) {
	unsigned found = path.find_last_of("/\\");
	return path.substr(found + 1);
	}

	void setupCompileArguments(
	const vector<string>& inputs, const vector<int>& kernels,
	const string& output_dir, const string& output_filename,
	const string& rsLib, vector<const char> args) {
	args->push_back(RsdCpuScriptImpl::BCC_EXE_PATH);
	args->push_back("-fPIC");
	args->push_back("-embedRSInfo");
	args->push_back("-mtriple");
	args->push_back(DEFAULT_TARGET_TRIPLE_STRING);
	args->push_back("-bclib");
	args->push_back(rsLib.c_str());
	for (const string& input : inputs) {
	args->push_back(input.c_str());
	}
	for (int kernel : kernels) {
	args->push_back("-k");
	string strKernel = std::to_string(kernel);
	args->push_back(strKernel.c_str());
	}
	args->push_back("-output_path");
	args->push_back(output_dir.c_str());
	args->push_back("-o");
	args->push_back(output_filename.c_str());
	args->push_back(nullptr);
	}

	string convertListToString(int n, const char* const* strs) {
	string ret;
	ret.append(strs[0]);
	for (int i = 1; i < n; i++) {
	ret.append(" ");
	ret.append(strs[i]);
	}
	return ret;
	}

	bool fuseAndCompile(const char** arguments,
	const string& commandLine) {
	const pid_t pid = fork();

	if (pid == -1) {
	ALOGE("Couldn't fork for bcc execution");
	return false;
	}

	if (pid == 0) {
	// Child process
	ALOGV("Invoking BCC with: %s", commandLine.c_str());
	execv(RsdCpuScriptImpl::BCC_EXE_PATH, (char* const*)arguments);

	ALOGE("execv() failed: %s", strerror(errno));
	abort();
	return false;
	}

	// Parent process
	int status = 0;
	const pid_t w = waitpid(pid, &status, 0);
	if (w == -1) {
	return false;
	}

	if (!WIFEXITED(status) \|\| WEXITSTATUS(status) != 0 ) {
	ALOGE("bcc terminated unexpectedly");
	return false;
	}

	return true;
	}
	#endif

	} // anonymous namespace

	void Batch::tryToCreateFusedKernel(const char *cacheDir) {
	#ifndef RS_COMPATIBILITY_LIB
	if (mClosures.size() < 2) {
	ALOGV("Compiler kernel fusion skipped due to only one or zero kernel in"
	" a script group batch.");
	return;
	}

	//===--------------------------------------------------------------------===//
	// Fuse the input kernels and generate native code in an object file
	//===--------------------------------------------------------------------===//

	std::vector<string> inputFiles;
	std::vector<int> slots;

	for (CPUClosure* cpuClosure : mClosures) {
	const Closure* closure = cpuClosure->mClosure;
	const ScriptKernelID* kernelID = closure->mKernelID.get();
	const Script* script = kernelID->mScript;

	if (script->isIntrinsic()) {
	return;
	}

	const RsdCpuScriptImpl *cpuScript =
	(const RsdCpuScriptImpl*)script->mHal.drv;

	const string& bitcodeFilename = cpuScript->getBitcodeFilePath();

	inputFiles.push_back(bitcodeFilename);
	slots.push_back(kernelID->mSlot);
	}

	string outputPath(tempnam(cacheDir, "fused"));
	string outputFileName = getFileName(outputPath);
	string objFilePath(outputPath);
	objFilePath.append(".o");
	string rsLibPath(SYSLIBPATH"/libclcore.bc");
	vector<const char*> arguments;
	setupCompileArguments(inputFiles, slots, cacheDir, outputFileName, rsLibPath,
	&arguments);
	string commandLine =
	convertListToString(arguments.size() - 1, arguments.data());

	if (!fuseAndCompile(arguments.data(), commandLine)) {
	return;
	}

	//===--------------------------------------------------------------------===//
	// Create and load the shared lib
	//===--------------------------------------------------------------------===//

	const char* resName = outputFileName.c_str();

	if (!SharedLibraryUtils::createSharedLibrary(cacheDir, resName)) {
	ALOGE("Failed to link object file '%s'", resName);
	return;
	}

	void* mSharedObj = SharedLibraryUtils::loadSharedLibrary(cacheDir, resName);
	if (mSharedObj == nullptr) {
	ALOGE("Unable to load '%s'", resName);
	return;
	}

	mExecutable = ScriptExecutable::createFromSharedObject(
	nullptr, // RS context. Unused.
	mSharedObj);

	#endif // RS_COMPATIBILITY_LIB
	}

	void CpuScriptGroup2Impl::execute() {
	for (auto batch : mBatches) {
	batch->setGlobalsForBatch();
	batch->run();
	}
	}

	void Batch::setGlobalsForBatch() {
	for (CPUClosure* cpuClosure : mClosures) {
	const Closure* closure = cpuClosure->mClosure;
	const ScriptKernelID* kernelID = closure->mKernelID.get();
	Script* s = kernelID->mScript;
	for (const auto& p : closure->mGlobals) {
	const void* value = p.second.first;
	int size = p.second.second;
	// We use -1 size to indicate an ObjectBase rather than a primitive type
	if (size < 0) {
	s->setVarObj(p.first->mSlot, (ObjectBase*)value);
	} else {
	s->setVar(p.first->mSlot, (const void*)&value, size);
	}
	}
	}
	}

	void Batch::run() {
	if (mExecutable != nullptr) {
	MTLaunchStruct mtls;
	const CPUClosure* firstCpuClosure = mClosures.front();
	const CPUClosure* lastCpuClosure = mClosures.back();

	firstCpuClosure->mSi->forEachMtlsSetup(
	(const Allocation**)&firstCpuClosure->mClosure->mArgs[0],
	firstCpuClosure->mClosure->mArgs.size(),
	lastCpuClosure->mClosure->mReturnValue,
	nullptr, 0, nullptr, &mtls);

	mtls.script = nullptr;
	mtls.fep.usr = nullptr;
	mtls.kernel = mExecutable->getForEachFunction(0);

	mGroup->getCpuRefImpl()->launchThreads(
	(const Allocation**)&firstCpuClosure->mClosure->mArgs[0],
	firstCpuClosure->mClosure->mArgs.size(),
	lastCpuClosure->mClosure->mReturnValue,
	nullptr, &mtls);

	return;
	}

	for (CPUClosure* cpuClosure : mClosures) {
	const Closure* closure = cpuClosure->mClosure;
	const ScriptKernelID* kernelID = closure->mKernelID.get();
	cpuClosure->mSi->preLaunch(kernelID->mSlot,
	(const Allocation**)&closure->mArgs[0],
	closure->mArgs.size(), closure->mReturnValue,
	cpuClosure->mUsrPtr, cpuClosure->mUsrSize,
	nullptr);
	}

	const CPUClosure* cpuClosure = mClosures.front();
	const Closure* closure = cpuClosure->mClosure;
	MTLaunchStruct mtls;

	if (cpuClosure->mSi->forEachMtlsSetup((const Allocation**)&closure->mArgs[0],
	closure->mArgs.size(),
	closure->mReturnValue,
	nullptr, 0, nullptr, &mtls)) {

	mtls.script = nullptr;
	mtls.kernel = (void (*)())&groupRoot;
	mtls.fep.usr = &mClosures;

	mGroup->getCpuRefImpl()->launchThreads(nullptr, 0, nullptr, nullptr, &mtls);
	}

	for (CPUClosure* cpuClosure : mClosures) {
	const Closure* closure = cpuClosure->mClosure;
	const ScriptKernelID* kernelID = closure->mKernelID.get();
	cpuClosure->mSi->postLaunch(kernelID->mSlot,
	(const Allocation**)&closure->mArgs[0],
	closure->mArgs.size(), closure->mReturnValue,
	nullptr, 0, nullptr);
	}
	}

	} // namespace renderscript
	} // namespace android