Kezunlin's Blog

#include <cuda_runtime.h>
#include <cublas.h>
#include <cublas_api.h>
#include <cublas_v2.h>

bool CompareFeatureMtoN_gpu(float * featureM, float * featureN, float * result, 
	int count_m, int count_n, int size, int gpu_id) {
	float *dev_featureM = 0;
	float *dev_featureN = 0;
	float *dev_result = 0;
	const float alpha = 1, beta = 0;
	cublasHandle_t handle;
	cudaError_t cudaStatus;

	cudaStatus = cudaSetDevice(gpu_id);
	if (cudaStatus != cudaSuccess) {
		printf("cudaSetDevice failed!  Do you have a CUDA-capable GPU installed?\n");
		goto out;
	}
	cublasCreate(&handle);

	cudaStatus = cudaMalloc((void**)&dev_featureM, count_m * size * sizeof(float));
	if (cudaStatus != cudaSuccess) {
		printf("%s, line %d, cudaMalloc failed!\n", __func__, __LINE__);
		goto out;
	}
	cudaStatus = cudaMalloc((void**)&dev_featureN, count_n * size * sizeof(float));
	if (cudaStatus != cudaSuccess) {
		printf("%s, line %d, cudaMalloc failed!\n", __func__, __LINE__);
		goto out;
	}
	cudaStatus = cudaMalloc((void**)&dev_result, count_m * count_n * sizeof(float));
	if (cudaStatus != cudaSuccess) {
		printf("%s, line %d, cudaMalloc failed!\n", __func__, __LINE__);
		goto out;
	}

	cudaStatus = cudaMemcpy(dev_featureM, featureM, count_m * size * sizeof(float), 
		cudaMemcpyHostToDevice);
	if (cudaStatus != cudaSuccess) {
		printf("%s, line %d, cudaMalloc failed!\n", __func__, __LINE__);
		goto out;
	}
	cudaStatus = cudaMemcpy(dev_featureN, featureN, count_n * size * sizeof(float), 
		cudaMemcpyHostToDevice);
	if (cudaStatus != cudaSuccess) {
		printf("%s, line %d, cudaMalloc failed!\n", __func__, __LINE__);
		goto out;
	}

	/*
	
	CUBLAS assumes that the matrix in the device is stored in column major:

	" where α and β are scalars, and A , B and C are matrices stored in column-major 
	format with dimensions op ( A ) m × k , op ( B ) k × n and C m × n , respectively. 
	 
	 Also, for matrix A


	 // Multiply the arrays A and B on GPU and save the result in C (coloum-major)
 	 // C(m,n) = A(m,k) * B(k,n)

	  cublasSgemm(handle, CUBLAS_OP_N, CUBLAS_OP_N, m, n, k, &alpha, A, lda, B, ldb, &beta, C, ldc);
	 */

	cublasSgemm(handle, CUBLAS_OP_T, CUBLAS_OP_N, count_n, count_m, size, 
		&alpha, dev_featureN, size, dev_featureM, size, &beta, dev_result, count_n);
	cudaStatus = cudaThreadSynchronize();

	cudaStatus = cudaMemcpy(result, dev_result, count_m * count_n  * sizeof(float), 
		cudaMemcpyDeviceToHost);
	if (cudaStatus != cudaSuccess) {
		printf("%s, line %d, cudaMemcpy failed!\n", __func__, __LINE__);
		goto out;
	}

out:
	if(dev_featureM) cudaFree(dev_featureM);
	if(dev_featureN) cudaFree(dev_featureN);
	if(dev_result) cudaFree(dev_result);
	cublasDestroy(handle);
	return cudaStatus == cudaSuccess;
}

void test_feature_compare()
{
	/*

	[a1]
	[a2]
	[a3]  
		 * [b1]
		   [b2]

	[10,35]
	[10,35]
	[10,35]
	*/
	std::vector<float> f1{0,1,2,3,4,5,6,7,8,9};
	std::vector<float> f2{1,1,1,1,1,0,0,0,0,0},f22{0,0,0,0,0,1,1,1,1,1};

	std::vector<std::vector<float>> A,B;
	// 3*10
	A.push_back(f1);
	A.push_back(f1);
	A.push_back(f1);

	// 10 * 2
	B.push_back(f2);
	B.push_back(f22);


	int m = 3;
	int n = 2; 
	int dim = 10;
	int gpu_id = 0;

	float* feature_m = new float[ m*dim ];
	float* feature_n = new float[ n*dim ];
	auto tmp = feature_m;
	for (int i = 0; i < m; i++) {
		for (int j = 0; j < dim; j++)
			*tmp++ = A[i][j];
	}

	tmp = feature_n;
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < dim; j++)
			*tmp++ = B[i][j];
	}

	printf("m = %d, n= %d, size= %d \n", m, n, dim); // 3, 2, 10

	//float* result = CompareFeatureMtoN(feature_m, m*dim, feature_n, n*dim, dim, gpu_id);

	float* result = new float[m*n];
	CompareFeatureMtoN_gpu(feature_m, feature_n, result, m, n, dim, gpu_id);

	tmp = result;
	for(int i=0;i<6;i++)
		printf("%f ", *(tmp++));

	delete []feature_m;
	delete []feature_n;
	delete []result;
}

#ifndef __CUDA_H_
#define __CUDA_H_
#include "cuda_runtime.h"
#include "curand.h"
#include "cublas_v2.h"

#define BLOCK 512

void check_error(cudaError_t status);

dim3 cuda_gridsize(size_t n);

float* cuda_make_array(float* x,size_t n);

void cuda_free(float* x_gpu);

void cuda_push_array(float *x_gpu,float* x,size_t n);

void cuda_pull_array(float *x_gpu,float* x,size_t n);


#endif

#include "cuda.h"
#include "blas.h"

#include <assert.h>
#include <stdlib.h>
#include <time.h>
#include <stdio.h>

void error(const char* s)
{
    perror(s);
    assert(0);
    exit(-1);
}

void check_error(cudaError_t status)
{
    //cudaDeviceSynchronize();
    cudaError_t status2 = cudaGetLastError();
    if (status != cudaSuccess)
    {   
        const char *s = cudaGetErrorString(status);
        char buffer[256];
        printf("CUDA Error: %s\n", s);
        assert(0);
        snprintf(buffer, 256, "CUDA Error: %s", s);
        error(buffer);
    } 
    if (status2 != cudaSuccess)
    {   
        const char *s = cudaGetErrorString(status);
        char buffer[256];
        printf("CUDA Error Prev: %s\n", s);
        assert(0);
        snprintf(buffer, 256, "CUDA Error Prev: %s", s);
        error(buffer);
    } 
}

dim3 cuda_gridsize(size_t n){
    size_t k = (n-1) / BLOCK + 1;
    size_t x = k;
    size_t y = 1;
    if(x > 65535){
        x = ceil(sqrt(k));
        y = (n-1)/(x*BLOCK) + 1;
    }
    dim3 d = {x, y, 1};
    //printf("%ld %ld %ld %ld\n", n, x, y, x*y*BLOCK);
    return d;
}

float* cuda_make_array(float* x,size_t n)
{
    float *x_gpu;
    size_t size = sizeof(float)*n;
    cudaError_t status = cudaMalloc((void **)&x_gpu, size);
    check_error(status);
    if(x){
        status = cudaMemcpy(x_gpu, x, size, cudaMemcpyHostToDevice);
        check_error(status);
    } else {
        fill_gpu(n, 0, x_gpu, 1);
    }
    if(!x_gpu) error("Cuda malloc failed\n");
    return x_gpu;
}

void cuda_free(float* x_gpu)
{
    cudaError_t status = cudaFree(x_gpu);
    check_error(status);
}

void cuda_push_array(float *x_gpu,float* x,size_t n)
{
    size_t size = sizeof(float)*n;
    cudaError_t status = cudaMemcpy(x_gpu,x,size,cudaMemcpyHostToDevice);
    check_error(status);
}

void cuda_pull_array(float *x_gpu,float* x,size_t n)
{
    size_t size = sizeof(float)*n;
    cudaError_t status = cudaMemcpy(x,x_gpu,size,cudaMemcpyDeviceToHost);
    check_error(status);
}

#ifndef __ACTIVATIONS_H_
#define __ACTIVATIONS_H_

typedef enum{
    LOGISTIC, RELU, RELIE, LINEAR, RAMP, TANH, PLSE, \
    LEAKY, ELU, LOGGY, STAIR, HARDTAN, LHTAN
} ACTIVATION;

void activate_array_gpu(float* x,int n,ACTIVATION a);

#endif

#include "activations.h"
#include "cuda.h"
#include "blas.h"

__device__ float lhtan_activate_kernel(float x)
{
    if(x < 0) return .001f*x;
    if(x > 1) return .001f*(x-1.f) + 1.f;
    return x;
}

__device__ float hardtan_activate_kernel(float x)
{
    if (x < -1) return -1;
    if (x > 1) return 1;
    return x;
}

__device__ float linear_activate_kernel(float x){return x;}
__device__ float logistic_activate_kernel(float x){return 1.f/(1.f + expf(-x));}
__device__ float loggy_activate_kernel(float x){return 2.f/(1.f + expf(-x)) - 1;}
__device__ float relu_activate_kernel(float x){return x*(x>0);}
__device__ float elu_activate_kernel(float x){return (x >= 0)*x + (x < 0)*(expf(x)-1);}
__device__ float relie_activate_kernel(float x){return (x>0) ? x : .01f*x;}
__device__ float ramp_activate_kernel(float x){return x*(x>0)+.1f*x;}
__device__ float leaky_activate_kernel(float x){return (x>0) ? x : .1f*x;}
__device__ float tanh_activate_kernel(float x){return (2.f/(1 + expf(-2*x)) - 1);}
__device__ float plse_activate_kernel(float x)
{
    if(x < -4) return .01f * (x + 4);
    if(x > 4)  return .01f * (x - 4) + 1;
    return .125f*x + .5f;
}
__device__ float stair_activate_kernel(float x)
{
    int n = floorf(x);
    if (n%2 == 0) return floorf(x/2);
    else return (x - n) + floorf(x/2);
}

__device__ float activate_kernel(float x, ACTIVATION a)
{
    switch(a){
        case LINEAR:
            return linear_activate_kernel(x);
        case LOGISTIC:
            return logistic_activate_kernel(x);
        case LOGGY:
            return loggy_activate_kernel(x);
        case RELU:
            return relu_activate_kernel(x);
        case ELU:
            return elu_activate_kernel(x);
        case RELIE:
            return relie_activate_kernel(x);
        case RAMP:
            return ramp_activate_kernel(x);
        case LEAKY:
            return leaky_activate_kernel(x);
        case TANH:
            return tanh_activate_kernel(x);
        case PLSE:
            return plse_activate_kernel(x);
        case STAIR:
            return stair_activate_kernel(x);
        case HARDTAN:
            return hardtan_activate_kernel(x);
        case LHTAN:
            return lhtan_activate_kernel(x);
    }
    return 0;
}

__global__ void activate_array_kernel(float *x, int n, ACTIVATION a)
{
    int i = (blockIdx.x + blockIdx.y*gridDim.x) * blockDim.x + threadIdx.x;
    if(i < n) x[i] = activate_kernel(x[i], a);
}

void activate_array_gpu(float *x, int n, ACTIVATION a)
{
    activate_array_kernel<<<cuda_gridsize(n), BLOCK>>>(x, n, a);
    check_error(cudaPeekAtLastError());
}

enum caffe::Phase phase = caffe::Phase::TEST;

std::string proto_filepath = "yolov3.prototxt";
std::string weight_filepath = "yolov3.caffemodel";
caffe::Net<float> net = caffe::Net<float>(proto_filepath, phase));
net.CopyTrainedLayersFrom(weight_filepath);

bool ReadProtoFromTextFile(const char* filename, Message* proto) {
    Encryption encryption;
  int fd = open(filename, O_RDONLY);
  CHECK_NE(fd, -1) << "File not found: " << filename;
  FileInputStream* input = new FileInputStream(fd);
  bool success = google::protobuf::TextFormat::Parse(input, proto);
  delete input;
  close(fd);
  return success;
}

bool ReadProtoFromBinaryFile(const char* filename, Message* proto) {
  int fd = open(filename, O_RDONLY);
  CHECK_NE(fd, -1) << "File not found: " << filename;
  ZeroCopyInputStream* raw_input = new FileInputStream(fd);
  CodedInputStream* coded_input = new CodedInputStream(raw_input);
  coded_input->SetTotalBytesLimit(kProtoReadBytesLimit, 536870912);

  bool success = proto->ParseFromCodedStream(coded_input);

  delete coded_input;
  delete raw_input;
  close(fd);
  return success;
}

bool ReadProtoFromTextFile(const char *filename, Message *proto) {
    Encryption encryption;
    string res = encryption.decryptTextFile(filename); // demo.prototxt
    istringstream ss(res);

    IstreamInputStream *input = new IstreamInputStream(&ss);

    bool success = google::protobuf::TextFormat::Parse(input, proto);
    delete input;
    return success;
}


bool ReadProtoFromBinaryFile(const char *filename, Message *proto) {
    Encryption encryption;
    string res = encryption.decryptModelFile(filename); // demo.caffemodel
    istringstream ss(res);
    
    IstreamInputStream *input = new IstreamInputStream(&ss);
    CodedInputStream *coded_input = new CodedInputStream(input);
    coded_input->SetTotalBytesLimit(kProtoReadBytesLimit, 536870912);

    bool success = proto->ParseFromCodedStream(coded_input);

    delete coded_input;
    delete input;
    return success;
}

std::string model_path = "model.libpt";
torch::jit::script::Module net = torch::jit::load(model_path);
assert(net != nullptr);

std::string model_content = ""; // read from file
std::istringstream ss(model_content);
torch::jit::script::Module net = torch::jit::load(ss);
assert(net != nullptr);

class  SHARED_EXPORT ThreadPool {
public:
	static ThreadPool* Instance(size_t max_thread_pool_size);
	~ThreadPool(); 

	// Add new work item to the pool.
	template<class F> 
	inline void Enqueue(F f)
	{
		io_service_.post(f);//sync, return immediately
	}

	void Free();

private:
	static std::shared_ptr<ThreadPool> m_pInstance;
	bool bfree;

	ThreadPool(size_t size);
	DISABLE_COPY_AND_ASSIGN(ThreadPool);

	boost::thread_group workers_;
	boost::asio::io_service io_service_;
	boost::asio::io_service::work work_;
};

template <typename T>
struct Foo
{
    void doSomething(T param);
};

#include "Foo.cpp" // here

template <typename T>
void Foo<T>::doSomething(T param)
{
    //implementation
}

// no implementation
template <typename T> struct Foo { ... };

#include "Foo.h"

// implementation of Foo's methods

// explicit instantiations
template class Foo<int>;
template class Foo<float>;
// You will only be able to use Foo with int or float

// template void TestClass::templateFunction<int, int>(int, int);

//OK, pointer to int 999
std::shared_ptr<int> sp(new int(999)); 


template< typename T >
struct array_deleter
{
  void operator ()( T const * p)
  { 
    delete[] p; 
  }
};

// pointer to int array, 
// (1) provide array deleter
std::shared_ptr<int> sp(new int[10], array_deleter<int>()); 

// (2) or lambda expression 
std::shared_ptr<int> sp(new int[10], [](int *p) { delete[] p; });

// (3) or use default_delete
std::shared_ptr<int> sp(new int[10], std::default_delete<int[]>());

// (4) or we can use unique_ptr
std::unique_ptr<int[]> up(new int[10]); // this will correctly call delete[]

// (5) or we use vector<int>, no need to provide deleter 
typedef std::vector<int> int_array_t;
std::shared_ptr<int_array_t> sp(new int_array_t(10));

std::memcpy(sp.get()->data(), arr, size);

std::shared_ptr<uchar> pImage(new uchar[length], std::default_delete<uchar[]>());
memcpy(pImage.get(), (void*)(data.sync_image().data().c_str()), length);
cv::Mat image = cv::Mat(height, width, CV_8UC3, pImage.get());

#include <nlohmann/json.hpp>

// for convenience
using json = nlohmann::json;

// create an empty structure (null)
json j;

// add a number that is stored as double (note the implicit conversion of j to an object)
j["pi"] = 3.141;

// add a Boolean that is stored as bool
j["happy"] = true;

// add a string that is stored as std::string
j["name"] = "Niels";

// add another null object by passing nullptr
j["nothing"] = nullptr;

// add an object inside the object
j["answer"]["everything"] = 42;

// add an array that is stored as std::vector (using an initializer list)
j["list"] = { 1, 0, 2 };

// add another object (using an initializer list of pairs)
j["object"] = { {"currency", "USD"}, {"value", 42.99} };

// instead, you could also write (which looks very similar to the JSON above)
json j2 = {
  {"pi", 3.141},
  {"happy", true},
  {"name", "Niels"},
  {"nothing", nullptr},
  {"answer", {
    {"everything", 42}
  }},
  {"list", {1, 0, 2}},
  {"object", {
    {"currency", "USD"},
    {"value", 42.99}
  }}
};

// create object from string literal
json j = "{ \"happy\": true, \"pi\": 3.141 }"_json;

// or even nicer with a raw string literal
auto j2 = R"(
  {
    "happy": true,
    "pi": 3.141
  }
)"_json;

// parse explicitly
auto j3 = json::parse("{ \"happy\": true, \"pi\": 3.141 }");


// explicit conversion to string
std::string s = j.dump();    // {\"happy\":true,\"pi\":3.141}

// serialization with pretty printing
// pass in the amount of spaces to indent
std::cout << j.dump(4) << std::endl;
// {
//     "happy": true,
//     "pi": 3.141
// }

// read a JSON file
std::ifstream i("file.json");
json j;
i >> j;

// write prettified JSON to another file
std::ofstream o("pretty.json");
o << std::setw(4) << j << std::endl;

namespace ns {
    // a simple struct to model a person
    struct person {
        std::string name;
        std::string address;
        int age;
    };
}

ns::person p = {"Ned Flanders", "744 Evergreen Terrace", 60};

// convert to JSON: copy each value into the JSON object
json j;
j["name"] = p.name;
j["address"] = p.address;
j["age"] = p.age;

// ...

// convert from JSON: copy each value from the JSON object
ns::person p {
    j["name"].get<std::string>(),
    j["address"].get<std::string>(),
    j["age"].get<int>()
};

using nlohmann::json;

namespace ns {
    void to_json(json& j, const person& p) {
        j = json{{"name", p.name}, {"address", p.address}, {"age", p.age}};
    }

    void from_json(const json& j, person& p) {
        j.at("name").get_to(p.name);
        j.at("address").get_to(p.address);
        j.at("age").get_to(p.age);
    }
} // namespace ns


// create a person
ns::person p {"Ned Flanders", "744 Evergreen Terrace", 60};

// conversion: person -> json
json j = p;

std::cout << j << std::endl;
// {"address":"744 Evergreen Terrace","age":60,"name":"Ned Flanders"}

// conversion: json -> person
auto p2 = j.get<ns::person>();

// that's it
assert(p == p2);

namespace nlohmann {

template <typename T>
struct adl_serializer {
    static void to_json(json& j, const T& value) {
        // calls the "to_json" method in T's namespace
    }

    static void from_json(const json& j, T& value) {
        // same thing, but with the "from_json" method
    }
};

}

struct move_only_type {
    move_only_type() = delete;
    move_only_type(int ii): i(ii) {}
    move_only_type(const move_only_type&) = delete;
    move_only_type(move_only_type&&) = default;

    int i;
};

namespace nlohmann {
    template <>
    struct adl_serializer<move_only_type> {
        // note: the return type is no longer 'void', and the method only takes
        // one argument
        static move_only_type from_json(const json& j) {
            return {j.get<int>()};
        }

        // Here's the catch! You must provide a to_json method! Otherwise you
        // will not be able to convert move_only_type to json, since you fully
        // specialized adl_serializer on that type
        static void to_json(json& j, move_only_type t) {
            j = t.i;
        }
    };
}

#pragma once

#include <nlohmann/json.hpp>
using json = nlohmann::json;
#include "sensor_data.h"
#include "rfid_info.h"

namespace nlohmann {
	template <>
	struct adl_serializer<SensorData> {
		// note: the return type is no longer 'void', and the method only takes
		// one argument
		static SensorData from_json(const json& j) {
			SensorData sensor_data;
			sensor_data.sensor_identify = j.at("SensorIdentify").get<string>();
			return sensor_data;
		}

		// Here's the catch! You must provide a to_json method! Otherwise you
		// will not be able to convert move_only_type to json, since you fully
		// specialized adl_serializer on that type
		static void to_json(json& j, SensorData t) {
			j = json{ {"SensorIdentify",t.sensor_identify},{"SensorType",t.sensor_type },{"Data",t.data} };
		}
	};
	template <>
	struct adl_serializer<RfidInfo> {
		// note: the return type is no longer 'void', and the method only takes
		// one argument
		static RfidInfo from_json(const json& j) {
			RfidInfo rfid_info;
			rfid_info.identify = j.at("Identify").get<string>();
			return rfid_info;
		}

		// Here's the catch! You must provide a to_json method! Otherwise you
		// will not be able to convert move_only_type to json, since you fully
		// specialized adl_serializer on that type
		static void to_json(json& j, RfidInfo t) {
			j = json{ { "Identify",t.identify },{ "Position",0 } };
		}
	};
}

// create a JSON value
json j = R"({"compact": true, "schema": 0})"_json;

// serialize to BSON
std::vector<std::uint8_t> v_bson = json::to_bson(j);

// 0x1B, 0x00, 0x00, 0x00, 0x08, 0x63, 0x6F, ...

// roundtrip
json j_from_bson = json::from_bson(v_bson);

//std
#include <queue>

//boost
#include <boost/thread.hpp>
#include <boost/bind.hpp>
#include <boost/asio.hpp>

namespace my { 
namespace algorithm {

template<typename Data>
class SHARED_EXPORT blocking_queue
{
private:
	std::queue<Data> the_queue;
	mutable boost::mutex the_mutex;
	boost::condition_variable the_condition_variable;

public:
	void push(Data const& data)
	{
		boost::mutex::scoped_lock lock(the_mutex);
		the_queue.push(data);
		lock.unlock();
		the_condition_variable.notify_one();
	}

	bool empty() const
	{
		boost::mutex::scoped_lock lock(the_mutex);
		return the_queue.empty();
	}

	size_t size() const
	{
		boost::mutex::scoped_lock lock(the_mutex);
		return the_queue.size();
	}

	bool try_pop(Data& popped_value)
	{
		boost::mutex::scoped_lock lock(the_mutex);
		if (the_queue.empty())
		{
			return false;
		}

		popped_value = the_queue.front();
		the_queue.pop();
		return true;
	}

	void wait_and_pop(Data& popped_value)
	{
		boost::mutex::scoped_lock lock(the_mutex);
		while (the_queue.empty())
		{
			the_condition_variable.wait(lock);
		}

		popped_value = the_queue.front();
		the_queue.pop();
	}

	void signal_exit()
	{
		Data data;
		push(data);
	}

};

}
}// end namespace

#pragma once
#include <iostream>
#include <assert.h>	

#include <queue>
#include <mutex>
#include <condition_variable>

#define MAX_CAPACITY 20

namespace my {
namespace algorithm {

template<typename T>
class SHARED_EXPORT BlockingQueue
{
public:
	BlockingQueue() 
	:mtx(), full_(), empty_(), capacity_(MAX_CAPACITY) { }


	void Push(const T& data){
		std::unique_lock<std::mutex> lock(mtx);
		while(queue_.size() == capacity_){
			full_.wait(lock );
		}

		assert(queue_.size() < capacity_);
		queue_.push(data);
		empty_.notify_all(); 
	}

	T Pop(){
		std::unique_lock<std::mutex> lock(mtx);
		while(queue_.empty()){
			empty_.wait(lock );
		}

		assert(!queue_.empty());
		T front(queue_.front());
		queue_.pop();
		full_.notify_all();
		return front;
	}

	T Front(){
		std::unique_lock<std::mutex> lock(mtx);
		while(queue_.empty()){
			empty_.wait(lock );
		}

		assert(!queue_.empty());
		T front(queue_.front());
		return front;
	}

	T Back(){
		std::unique_lock<std::mutex> lock(mtx);
		while(queue_.empty()){
			empty_.wait(lock );
		}

		assert(!queue_.empty());
		T back(queue_.back());
		return back;
	}

	size_t Size(){
		std::lock_guard<std::mutex> lock(mtx);
		return queue_.size();
	}

	bool Empty(){
		std::unique_lock<std::mutex> lock(mtx);
		return queue_.empty();
	}

	void SetCapacity(const size_t capacity){
		capacity_ = (capacity > 0 ? capacity : MAX_CAPACITY);
	}

private:
	//DISABLE_COPY_AND_ASSIGN(BlockingQueue);
	BlockingQueue(const BlockingQueue& rhs);
	BlockingQueue& operator= (const BlockingQueue& rhs);

private:
	mutable std::mutex mtx;
	std::condition_variable full_;
	std::condition_variable empty_;
	std::queue<T> queue_;
	size_t capacity_; 
};


}
}// end namespace

#include <colorwheel.h>

/* Predefined printf styled messages */
CW_PRINT_NORMAL(message, ...);
CW_PRINT_ALARM(message, ...);
CW_PRINT_CRITICAL(message, ...);
CW_PRINT_FAULT(message, ...);
CW_PRINT_VALID(message, ...);
CW_PRINT_INFO(message, ...);

/* Predefined trace styled messages (indicates file, function and line) */
CW_TRACE_NORMAL(message, ...);
CW_TRACE_ALARM(message, ...);
CW_TRACE_CRITICAL(message, ...);
CW_TRACE_FAULT(message, ...);
CW_TRACE_VALID(message, ...);
CW_TRACE_INFO(message, ...);

#include <colorwheel.h>

void demo_colorwheel(void)
{
    CW_TRACE_NORMAL("This is a normal information");
    CW_TRACE_INFO("This is a noticeable information");
    CW_TRACE_FAULT("Ooops something might have gone wrong");
    CW_TRACE_VALID("Finally it's okay, don't worry");
    //CW_TRACE_NORMAL("Nevermind");
	int value = 10;
	CW_TRACE_CRITICAL("It was way worse than expected! Computer will explode in %d s", value);
    CW_TRACE_ALARM("IT IS TOO LATE RUN AWAY");
}