int initializeCOM()
{
    // Step 1: --------------------------------------------------
    // Initialize COM. ------------------------------------------

	hres =  CoInitializeEx(0, COINIT_MULTITHREADED); 
    if (FAILED(hres))
    {
        cout << "Failed to initialize COM library. Error code = 0x" << hex << hres << endl;
        return 1;                  // Program has failed.
    }

    // Step 2: --------------------------------------------------
    // Set general COM security levels --------------------------

    hres =  CoInitializeSecurity(
        NULL, 
        -1,                          // COM authentication
        NULL,                        // Authentication services
        NULL,                        // Reserved
        RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication 
        RPC_C_IMP_LEVEL_IDENTIFY,    // Default Impersonation  
        NULL,                        // Authentication info
        EOAC_NONE,                   // Additional capabilities 
        NULL                         // Reserved
        );

    if (FAILED(hres))
    {
        cout << "Failed to initialize security. Error code = 0x" << hex << hres << endl;
        //CoUninitialize();
        return 1;                    // Program has failed.
    }

	return 0;
}


unsigned __stdcall getDataCPU( void* pArguments )
{
	int step = (int) pArguments;
	IPADDRESS ipAddress = ipAddress_vec[step];
	//cout << ipAddress.ipAddress  <<endl;

	IWbemLocator *pLoc = NULL;
	IWbemServices *pSvc = NULL;

    // Step 3: ---------------------------------------------------
    // Obtain the initial locator to WMI -------------------------

    //pLoc = NULL;

    hres = CoCreateInstance(
        CLSID_WbemLocator,             
        0, 
        CLSCTX_INPROC_SERVER, 
        IID_IWbemLocator, (LPVOID *) &pLoc);
 
    if (FAILED(hres))
    {
        cout << "Failed to create IWbemLocator object." << " Err code = 0x" << hex << hres << endl;
        CoUninitialize();
        return 1;                 // Program has failed.
    }

	// Connect to the remote root\cimv2 namespace
    // and obtain pointer pSvc to make IWbemServices calls.
	char computerName[50];
	char* var1 = "\\\\";
	char* var2 = "\\root\\cimv2";
	sprintf(computerName, "%s%s%s", var1, ipAddress.ipAddress, var2);
   
    hres = pLoc->ConnectServer(
		_bstr_t(computerName),
        NULL,                              // User name
		NULL,                              // User password
        NULL,                              // Locale             
        NULL,                              // Security flags
		NULL,                              // Authority
        NULL,                              // Context object 
        &pSvc                              // IWbemServices proxy
        );

    if (FAILED(hres))
    {
		//cout << "Not connect to remote computer:" << ipAddress.ipAddress << endl;
        return 1;                // Program has failed.
    }

	//cout << "Connect: " << ipAddress.ipAddress << endl;

    // Step 6: --------------------------------------------------
    // Set security levels on a WMI connection ------------------

    hres = CoSetProxyBlanket(
       pSvc,                           // Indicates the proxy to set
       RPC_C_AUTHN_DEFAULT,            // RPC_C_AUTHN_xxx
       RPC_C_AUTHZ_DEFAULT,            // RPC_C_AUTHZ_xxx
       COLE_DEFAULT_PRINCIPAL,         // Server principal name 
       RPC_C_AUTHN_LEVEL_PKT_PRIVACY,  // RPC_C_AUTHN_LEVEL_xxx 
       RPC_C_IMP_LEVEL_IMPERSONATE,    // RPC_C_IMP_LEVEL_xxx
       NULL,                           // client identity
       EOAC_NONE                       // proxy capabilities 
    );

    if (FAILED(hres))
    {
        return 1;               // Program has failed.
    }

	CPU_MEMORY cpu_memory;
	cpu_memory.employeeID = ipAddress.employeeID;



	//++++++++++++++++++++++++++++
	// Расчет процента загрузки ЦП.

	long long N1, N2, D1, D2;
	long double yDivision = 0;
	long long cpu = 0;
	long long time = 0;

    // Step 7: --------------------------------------------------
    // Use the IWbemServices pointer to make requests of WMI ----
    IEnumWbemClassObject* pEnumerator = NULL;
    hres = pSvc->ExecQuery(
        bstr_t("WQL"), 
		//bstr_t("Select * from Win32_PerfFormattedData_Counters_ProcessorInformation where Name = '_Total'"),
		bstr_t("Select * from Win32_PerfRawData_PerfOS_Processor where Name='_Total'"),
        WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, 
        NULL,
        &pEnumerator);
    
    if (FAILED(hres))
    {
        cout << "Query for operating system name failed." << " Error code = 0x" << hex << hres << endl;
        return 1;               // Program has failed.
    }


    // Step 8: -------------------------------------------------
    // Secure the enumerator proxy
    hres = CoSetProxyBlanket(
        pEnumerator,                    // Indicates the proxy to set
        RPC_C_AUTHN_DEFAULT,            // RPC_C_AUTHN_xxx
        RPC_C_AUTHZ_DEFAULT,            // RPC_C_AUTHZ_xxx
        COLE_DEFAULT_PRINCIPAL,         // Server principal name 
        RPC_C_AUTHN_LEVEL_PKT_PRIVACY,  // RPC_C_AUTHN_LEVEL_xxx 
        RPC_C_IMP_LEVEL_IMPERSONATE,    // RPC_C_IMP_LEVEL_xxx
        NULL,                           // client identity
        EOAC_NONE                       // proxy capabilities 
        );

    if (FAILED(hres))
    {
        cout << "Could not set proxy blanket on enumerator. Error code = 0x" << hex << hres << endl;
		pEnumerator->Release();
        return 1;               // Program has failed.
    }

    // Step 9: -------------------------------------------------
    // Get the data from the query in step 7 -------------------
 
    IWbemClassObject *pclsObj = NULL;
    ULONG uReturn = 0;

    while (pEnumerator)
    {
        HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn);
		/*
		+++++++++++++++++++++++++++++
		ОШИБКА ТУТ
		+++++++++++++++++++++++++++++
		*/

        if(0 == uReturn)
        {
            break;
        }

        VARIANT vtProp;
		VARIANT vtProp2;

		hr = pclsObj->Get(L"PercentProcessorTime", 0, &vtProp, 0, 0);
		hr = pclsObj->Get(L"TimeStamp_Sys100NS", 0, &vtProp2, 0, 0);

		N1 = (long long) _wtoi64(vtProp.bstrVal);
		D1 = (long long) _wtoi64(vtProp2.bstrVal);
		
		VariantClear(&vtProp);
		VariantClear(&vtProp2);

        pclsObj->Release();
        pclsObj = NULL;
    }

    // Cleanup
    pEnumerator->Release();
	if( pclsObj )
    {
        pclsObj->Release();
    }

	//++++++++++++++++++++++++++++++++
	Sleep(2000);
	//++++++++++++++++++++++++++++++++

    // Step 7: --------------------------------------------------
    // Use the IWbemServices pointer to make requests of WMI ----
    hres = pSvc->ExecQuery(
        bstr_t("WQL"), 
		bstr_t("Select * from Win32_PerfRawData_PerfOS_Processor where Name='_Total'"),
        WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, 
        NULL,
        &pEnumerator);
    
    if (FAILED(hres))
    {
        cout << "Query for operating system name failed." << " Error code = 0x" << hex << hres << endl;
        return 1;               // Program has failed.
    }


    // Step 8: -------------------------------------------------
    // Secure the enumerator proxy
    hres = CoSetProxyBlanket(
        pEnumerator,                    // Indicates the proxy to set
        RPC_C_AUTHN_DEFAULT,            // RPC_C_AUTHN_xxx
        RPC_C_AUTHZ_DEFAULT,            // RPC_C_AUTHZ_xxx
        COLE_DEFAULT_PRINCIPAL,         // Server principal name 
        RPC_C_AUTHN_LEVEL_PKT_PRIVACY,  // RPC_C_AUTHN_LEVEL_xxx 
        RPC_C_IMP_LEVEL_IMPERSONATE,    // RPC_C_IMP_LEVEL_xxx
        NULL,                           // client identity
        EOAC_NONE                       // proxy capabilities 
        );

    if (FAILED(hres))
    {
        cout << "Could not set proxy blanket on enumerator. Error code = 0x" << hex << hres << endl;
        return 1;               // Program has failed.
    }

    // Step 9: -------------------------------------------------
    // Get the data from the query in step 7 -------------------

    uReturn = 0;

    while (pEnumerator)
    {
        HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn);

        if(0 == uReturn)
        {
            break;
        }

        VARIANT vtProp;
		VARIANT vtProp2;

		hr = pclsObj->Get(L"PercentProcessorTime", 0, &vtProp, 0, 0);
		hr = pclsObj->Get(L"TimeStamp_Sys100NS", 0, &vtProp2, 0, 0);

		N2 = (long long) _wtoi64(vtProp.bstrVal);
		D2 = (long long) _wtoi64(vtProp2.bstrVal);
		
		VariantClear(&vtProp);
		VariantClear(&vtProp2);

		cpu = (long long)N2 - (long long)N1;
		time = (long long)D2 - (long long)D1;

		yDivision = (long double)cpu/(long double)time;

		long double percentUsingProcessor = 0;
		percentUsingProcessor =  (1 - yDivision) * 100;
		
		cpu_memory.percentCPU = (int) ceil(percentUsingProcessor);

        pclsObj->Release();
        pclsObj = NULL;
    }

    // Cleanup
    pEnumerator->Release();
	if( pclsObj )
    {
        pclsObj->Release();
    }


	//+++++++++++++++++++++++++++++++++++


	pSvc->Release();
	pLoc->Release();
	//CoUninitialize();

    return 0;   // Program successfully completed.
}

int main(int argc,char* argv[])
  {
  int b = 0; 
  //b = initializeCOM();
  try
    {
...................
	b = initializeCOM();
	while (i < 120)
	{
		rs = stmt->executeQuery();

		// вычесление процессов будет один раз в 15 шагов.
		param = (double) step_circle/ (double) 15;
		fractpart = modf (param , &intpart);
		if (fractpart == 0) {
			flag_process = 1;
		} else {
			flag_process = 0;
		}

		step_circle++;
		while (rs->next())
			  {
			  ipAddressStrucIn.employeeID = rs->getInt (1);
			  t1  = rs->getInt (2);
			  t2  = rs->getInt (3);
			  t3  = rs->getInt (4);
			  t4  = rs->getInt (5);
			  ss << t1 << "." << t2 << "." << t3 << "." << t4;
			  t = ss.str();
			  ipAddressStrucIn.ipAddress = strdup(t.c_str());

			  ipAddress_vec.push_back(ipAddressStrucIn);

			  //clear
			  ss.str(std::string());
			  ss.clear();
			  t.clear();
			  }
		
		HANDLE threads[1000];
		SECURITY_ATTRIBUTES  sa = {sizeof(SECURITY_ATTRIBUTES), 0, TRUE};


		cout << "start threads for: " << ipAddress_vec.size() << endl;

		//b = initializeCOM();
		
		for (d=0;d<(int) ipAddress_vec.size();d++) {
			//unsigned threadId;
			//threads[d] = (HANDLE)_beginthreadex(&sa, 4096, &getDataCPU, (void *) d, 0, NULL);
			threads[d] = (HANDLE)_beginthreadex(NULL, 0, &getDataCPU, (void *) d, 0, NULL);
		}

		//WaitForMultipleObjects(ipAddress_vec.size(), threads, true, INFINITE);
		d=0;
		for (d=0;d<(int) ipAddress_vec.size();d++) {
			WaitForSingleObject( threads[d], 30000 );
			CloseHandle(threads[d]);
		}
		

		
		//hresStep++;

		cout << "Request complited for " << ipAddress_vec.size() << " computers" << endl;

		cout << "stop threads" << endl;

		//+++++++Insert Oracle
		cout << "Insert Oracle" << endl;
		int c;
		for (c=0;c<cpu_memory_vec.size();c++) {
			cpu_memory = cpu_memory_vec[c];
			ss << insert << cpu_memory.employeeID << ", " << cpu_memory.percentCPU << ", " << cpu_memory.percentMemory << ", " << cpu_memory.freeMemory << ")";
			t = ss.str();
			insertSQL = t.c_str();
			stmt2->execute(insertSQL);
			ss.str(std::string());
			ss.clear();
			t.clear();
		}

		stmt2->execute("COMMIT");

		int h;
		if (flag_process == 1) {
			cout << "Insert Oracle Process" << endl;
			for (h=0;h<process_vec.size();h++) {
				getProcess = process_vec[h];
				ss << insertProcess << getProcess.employeeID << ", '" << getProcess.name << "', " << getProcess.memory << ", " << getProcess.proc_time << ")";
				t = ss.str();
				insertSQLProcess = t.c_str();
				//wcout << insertSQLProcess << endl;
				stmt2->execute(insertSQLProcess);
				ss.str(std::string());
				ss.clear();
				t.clear();

				double param2, fractpart2, intpart2;
				param2 = (double) h/ (double) 15;
				fractpart2 = modf (param2 , &intpart2);
				if (fractpart2 == 0) {
					stmt2->execute("COMMIT");
				}
			}
			cout << "End insert Oracle Process" << endl;
			stmt2->execute("COMMIT");
		}

		cout << "End insert Oracle" << endl;

		//hres->
		cpu_memory_vec.clear();
		process_vec.clear();
		ipAddress_vec.clear();
		//+++++++++++++++++++

		stmt->closeResultSet(rs);
		Sleep(60000); //засыпаем на 1 минуту
		i++;
	}

	CoUninitialize();

    //Освобождение ресурсов connect Oracle
    env->terminateConnection(conn);
    Environment::terminateEnvironment(env);
    }
	catch(SQLException &sqlExcp)
    {
    cerr << sqlExcp.getErrorCode() << " " << sqlExcp.getMessage() << endl;
    }

  Sleep(10000);

  // Освобождение ресурсов connect COM WMI
  //pSvc->Release();
  //pLoc->Release();
  //CoUninitialize();

  return 0;
}