nnpack详解

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/time.h>
#include<nnpack.h>
int main(int argc , char** argv)
{
	//init nnpack
	enum nnp_status init_status = nnp_initialize();
	if (init_status != nnp_status_success) {
		fprintf(stderr, "NNPACK initialization failed: error code %d\n", init_status);
		exit(EXIT_FAILURE);
	}

        enum nnp_convolution_algorithm algorithm = nnp_convolution_algorithm_auto;
        const size_t batch_size = 1;
        const size_t input_channels = 1;
        const size_t output_channels = 1;
        const struct nnp_padding input_padding = { 0, 0, 0, 0 };
        const struct nnp_size input_size ={ 4, 4 };
        const struct nnp_size kernel_size = { 3, 3 },;
        const struct nnp_size output_size = {
                .width = (input_padding.left + input_size.width + input_padding.right - kernel_size.width) / output_subsampling.width + 1,
                .height = (input_padding.top + input_size.height + input_padding.bottom - kernel_size.height) / output_subsampling.height + 1
        };
	int iter=1;

	//malloc memory for input, kernel, output, bias
	float* input = (float*)malloc(batch_size * input_channels *input_size.height *input_size.width * sizeof(float));
	float* kernel = (float*)malloc(input_channels * output_channels * kernel_size.height * kernel_size.width * sizeof(float));
	float* output = (float*)malloc(batch_size* output_channels * output_size.height * output_size.width * sizeof(float));
	float* bias = (float*)malloc(output_channels * sizeof(float));

	pthreadpool_t threadpool=NULL;
	//flase:only one thread, true: mutiple threads 
	if (false) { 
                threadpool = pthreadpool_create(options.threads);
                printf("Threads: %zu\n", pthreadpool_get_threads_count(threadpool));
    }

	struct nnp_profile computation_profile;//use for compute time;
	//init input data
	int i,j;
	for(int c=0; c<input_channels;c++ ){
		for(i=0; i<input_size.height; i++){
			for(j=0; j<input_size.width; j++){
				input[c*input_size.height*input_size.width+i*input_size.width+j] = (i*input_size.width+j)*1.0;
			}
		}
	}

	//init kernel data
	for(int i=0; i<output_channels;i++ ){
		for(j=0; j<input_channels*kernel_size.height*kernel_size.width; j++){
			kernel[i*input_channels*kernel_size.height*kernel_size.width+j] = 1.0;			
		}
	}

	//init bias data
	for(int i=0; i<output_channels;i++ ){
		bias[i] = 1.0;
	}

	//execute conv
	struct timeval conv_start;
	struct timeval conv_end;
	gettimeofday(&conv_start,NULL);
	for(int i=0;i<iter;i++){
		nnp_convolution_output(algorithm,
					batch_size,
					input_channels,
					output_channels,
					input_size,
					input_padding,
					kernel_size,
					input,
					kernel,
					bias,
					output,
					threadpool,
					&computation_profile);
	}
	gettimeofday(&conv_end,NULL);
	//printf ouput data
	for(i=0;i<output_channels; i++){
		for(j=0;j<output_size.height*output_size.width; j++){
			printf("%f\t",output[i*output_size.height*output_size.width+j]);	
		}
		printf("\n");	
	}
	float conv_time_use = 1000.0*(float)(conv_end.tv_sec-conv_start.tv_sec)+(float)(conv_end.tv_usec-conv_start.tv_usec)/1000.0;
	printf("conv Time use = %f(ms)\n",conv_time_use);
	printf("conv mean Time use = %f(ms) / iter\n",conv_time_use/iter);
	return 0;
}