gallivm.h File Reference

Include dependency graph for gallivm.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Enumerations
enum	gallivm_shader_type { GALLIVM_VS, GALLIVM_FS }
enum	gallivm_vector_layout { GALLIVM_AOS, GALLIVM_SOA }
Functions
struct gallivm_ir *	gallivm_ir_new (enum gallivm_shader_type type)
void	gallivm_ir_set_layout (struct gallivm_ir *ir, enum gallivm_vector_layout layout)
void	gallivm_ir_set_components (struct gallivm_ir *ir, int num)
void	gallivm_ir_fill_from_tgsi (struct gallivm_ir *ir, const struct tgsi_token *tokens)
void	gallivm_ir_delete (struct gallivm_ir *ir)
struct gallivm_prog *	gallivm_ir_compile (struct gallivm_ir *ir)
void	gallivm_prog_inputs_interpolate (struct gallivm_prog *prog, float(*inputs)[PIPE_MAX_SHADER_INPUTS][4], const struct tgsi_interp_coef *coefs)
void	gallivm_prog_dump (struct gallivm_prog *prog, const char *file_prefix)
struct gallivm_cpu_engine *	gallivm_cpu_engine_create (struct gallivm_prog *prog)
	This function creates a CPU based execution engine for the given gallivm_prog.
struct gallivm_cpu_engine *	gallivm_global_cpu_engine ()
int	gallivm_cpu_vs_exec (struct gallivm_prog *prog, struct tgsi_exec_machine *machine, const float(*input)[4], unsigned num_inputs, float(*output)[4], unsigned num_outputs, const float(*constants)[4], unsigned count, unsigned input_stride, unsigned output_stride)
	This function is used to execute the gallivm_prog in software.
int	gallivm_cpu_fs_exec (struct gallivm_prog *prog, float x, float y, float(*dests)[PIPE_MAX_SHADER_INPUTS][4], float(*inputs)[PIPE_MAX_SHADER_INPUTS][4], float(*consts)[4], struct tgsi_sampler *samplers)
void	gallivm_cpu_jit_compile (struct gallivm_cpu_engine *ee, struct gallivm_prog *prog)
	This function JIT compiles the given gallivm_prog with the given cpu based execution engine.
void	gallivm_cpu_engine_delete (struct gallivm_cpu_engine *ee)

---

Enumeration Type Documentation

enum gallivm_shader_type

Enumerator:

GALLIVM_VS
GALLIVM_FS

Definition at line 63 of file gallivm.h.

                         {
   GALLIVM_VS,
   GALLIVM_FS
};

enum gallivm_vector_layout

Enumerator:

GALLIVM_AOS
GALLIVM_SOA

Definition at line 68 of file gallivm.h.

                           {
   GALLIVM_AOS,
   GALLIVM_SOA
};

---

Function Documentation

struct gallivm_cpu_engine* gallivm_cpu_engine_create

(

struct gallivm_prog *

prog

)

[read]

This function creates a CPU based execution engine for the given gallivm_prog.

gallivm_cpu_engine should be used as a singleton throughout the library. Before executing gallivm_prog_exec one needs to call gallivm_cpu_jit_compile. The gallivm_prog instance which is being passed to the constructor is being automatically JIT compiled so one shouldn't call gallivm_cpu_jit_compile with it again.

Definition at line 131 of file gallivm_cpu.cpp.

References gallivm_cpu_engine::engine, func_for_shader(), gallivm_prog::function, and gallivm_prog::module.

{
   struct gallivm_cpu_engine *cpu = (struct gallivm_cpu_engine *)
                                    calloc(1, sizeof(struct gallivm_cpu_engine));
   llvm::Module *mod = static_cast<llvm::Module*>(prog->module);
   llvm::ExistingModuleProvider *mp = new llvm::ExistingModuleProvider(mod);
   llvm::ExecutionEngine *ee = llvm::ExecutionEngine::create(mp, false);
   ee->DisableLazyCompilation();
   cpu->engine = ee;

   llvm::Function *func = func_for_shader(prog);

   prog->function = ee->getPointerToFunction(func);
   CPU = cpu;
   return cpu;
}

void gallivm_cpu_engine_delete

(

struct gallivm_cpu_engine *

ee

)

Definition at line 169 of file gallivm_cpu.cpp.

{
   free(cpu);
}

int gallivm_cpu_fs_exec	(	struct gallivm_prog *	prog,
		float	x,
		float	y,
		float *	dests[PIPE_MAX_SHADER_INPUTS][4],
		float *	inputs[PIPE_MAX_SHADER_INPUTS][4],
		float *	consts[4],
		struct tgsi_sampler *	samplers
	)

void gallivm_cpu_jit_compile	(	struct gallivm_cpu_engine *	cpu,
		struct gallivm_prog *	prog
	)

This function JIT compiles the given gallivm_prog with the given cpu based execution engine.

The reference to the generated machine code entry point will be stored in the gallivm_prog program. After executing this function one can call gallivm_prog_exec in order to execute the gallivm_prog on the CPU.

Definition at line 155 of file gallivm_cpu.cpp.

References assert, gallivm_cpu_engine::engine, func_for_shader(), gallivm_prog::function, and gallivm_prog::module.

{
   llvm::Module *mod = static_cast<llvm::Module*>(prog->module);
   llvm::ExistingModuleProvider *mp = new llvm::ExistingModuleProvider(mod);
   llvm::ExecutionEngine *ee = cpu->engine;
   assert(ee);
   /*FIXME : remove */
   ee->DisableLazyCompilation();
   ee->addModuleProvider(mp);

   llvm::Function *func = func_for_shader(prog);
   prog->function = ee->getPointerToFunction(func);
}

int gallivm_cpu_vs_exec	(	struct gallivm_prog *	prog,
		struct tgsi_exec_machine *	machine,
		const float *	input[4],
		unsigned	num_inputs,
		float *	output[4],
		unsigned	num_outputs,
		const float *	constants[4],
		unsigned	count,
		unsigned	input_stride,
		unsigned	output_stride
	)

This function is used to execute the gallivm_prog in software.

Before calling this function the gallivm_prog has to be JIT compiled with the gallivm_cpu_jit_compile function.

Definition at line 191 of file gallivm_cpu.cpp.

References assert, tgsi_exec_channel::f, gallivm_prog::function, tgsi_exec_machine::Inputs, MAX_TGSI_VERTICES, MIN2, tgsi_exec_machine::Outputs, tgsi_exec_machine::Temps, and tgsi_exec_vector::xyzw.

{
   unsigned int i, j;
   unsigned slot;
   vertex_shader_runner runner = reinterpret_cast<vertex_shader_runner>(prog->function);

   assert(runner);

   for (i = 0; i < count; i += MAX_TGSI_VERTICES) {
      unsigned int max_vertices = MIN2(MAX_TGSI_VERTICES, count - i);

      /* Swizzle inputs.
       */
      for (j = 0; j < max_vertices; j++) {
         for (slot = 0; slot < num_inputs; slot++) {
            machine->Inputs[slot].xyzw[0].f[j] = input[slot][0];
            machine->Inputs[slot].xyzw[1].f[j] = input[slot][1];
            machine->Inputs[slot].xyzw[2].f[j] = input[slot][2];
            machine->Inputs[slot].xyzw[3].f[j] = input[slot][3];
         }

         input = (const float (*)[4])((const char *)input + input_stride);
      }

      /* run shader */
      runner(machine->Inputs,
             machine->Outputs,
             (float (*)[4]) constants,
             machine->Temps);

      /* Unswizzle all output results
       */
      for (j = 0; j < max_vertices; j++) {
         for (slot = 0; slot < num_outputs; slot++) {
            output[slot][0] = machine->Outputs[slot].xyzw[0].f[j];
            output[slot][1] = machine->Outputs[slot].xyzw[1].f[j];
            output[slot][2] = machine->Outputs[slot].xyzw[2].f[j];
            output[slot][3] = machine->Outputs[slot].xyzw[3].f[j];
         }
         output = (float (*)[4])((char *)output + output_stride);
      }
   }

   return 0;
}

struct gallivm_cpu_engine* gallivm_global_cpu_engine

(

)

[read]

Definition at line 174 of file gallivm_cpu.cpp.

{
   return CPU;
}

struct gallivm_prog* gallivm_ir_compile

(

struct gallivm_ir *

ir

)

[read]

Definition at line 302 of file gallivm.cpp.

References AddStandardCompilePasses(), gallivm_ir::interpolators, gallivm_prog::interpolators, gallivm_prog::module, gallivm_ir::module, gallivm_ir::num_consts, gallivm_prog::num_consts, gallivm_ir::num_interp, and gallivm_prog::num_interp.

{
   struct gallivm_prog *prog =
      (struct gallivm_prog *)calloc(1, sizeof(struct gallivm_prog));

   std::cout << "Before optimizations:"<<std::endl;
   ir->module->dump();
   std::cout<<"-------------------------------"<<std::endl;

   PassManager veri;
   veri.add(createVerifierPass());
   veri.run(*ir->module);
   llvm::Module *mod = llvm::CloneModule(ir->module);
   prog->num_consts = ir->num_consts;
   memcpy(prog->interpolators, ir->interpolators, sizeof(prog->interpolators));
   prog->num_interp = ir->num_interp;

   /* Run optimization passes over it */
   PassManager passes;
   passes.add(new TargetData(mod));
   AddStandardCompilePasses(passes);
   passes.run(*mod);
   prog->module = mod;

   std::cout << "After optimizations:"<<std::endl;
   mod->dump();

   return prog;
}

void gallivm_ir_delete

(

struct gallivm_ir *

ir

)

Definition at line 296 of file gallivm.cpp.

References gallivm_ir::module.

{
   delete ir->module;
   free(ir);
}

void gallivm_ir_fill_from_tgsi	(	struct gallivm_ir *	ir,
		const struct tgsi_token *	tokens
	)

Definition at line 285 of file gallivm.cpp.

References gallivm_ir_dump(), gallivm_ir::module, tgsi_dump(), and tgsi_to_llvmir().

{
   std::cout << "Creating llvm from: " <<std::endl;
   tgsi_dump(tokens, 0);

   llvm::Module *mod = tgsi_to_llvmir(ir, tokens);
   ir->module = mod;
   gallivm_ir_dump(ir, 0);
}

struct gallivm_ir* gallivm_ir_new

(

enum gallivm_shader_type

type

)

[read]

Definition at line 263 of file gallivm.cpp.

References GLOBAL_ID, gallivm_ir::id, and gallivm_ir::type.

{
   struct gallivm_ir *ir =
      (struct gallivm_ir *)calloc(1, sizeof(struct gallivm_ir));
   ++GLOBAL_ID;
   ir->id   = GLOBAL_ID;
   ir->type = type;

   return ir;
}

void gallivm_ir_set_components	(	struct gallivm_ir *	ir,
		int	num
	)

Definition at line 280 of file gallivm.cpp.

References gallivm_ir::num_components.

{
   ir->num_components = num;
}

void gallivm_ir_set_layout	(	struct gallivm_ir *	ir,
		enum gallivm_vector_layout	layout
	)

Definition at line 274 of file gallivm.cpp.

References gallivm_ir::layout.

{
   ir->layout = layout;
}

void gallivm_prog_dump	(	struct gallivm_prog *	prog,
		const char *	file_prefix
	)

void gallivm_prog_inputs_interpolate	(	struct gallivm_prog *	prog,
		float *	inputs[PIPE_MAX_SHADER_INPUTS][4],
		const struct tgsi_interp_coef *	coefs
	)

---